diff options
| author | Mehdi Dogguy <mehdi@debian.org> | 2010-07-07 18:10:18 +0200 |
|---|---|---|
| committer | Mehdi Dogguy <mehdi@debian.org> | 2010-07-07 18:10:18 +0200 |
| commit | e358163ec8f2d5c1fb7d36dc6ec6d8e3e23e0216 (patch) | |
| tree | 31eef7f795249f84fc66285052f4b299c0f83cee | |
| parent | 94366a443886074fc9264576403ddf37f999c0b8 (diff) | |
Imported Upstream version 2.03
108 files changed, 5866 insertions, 3534 deletions
@@ -3,23 +3,23 @@ src/calendar.cmo: src/time.cmi src/date.cmi src/calendar_builder.cmi \ src/calendar.cmx: src/time.cmx src/date.cmx src/calendar_builder.cmx \ src/calendar.cmi src/calendar_builder.cmo: src/utils.cmi src/time_sig.cmi src/time_Zone.cmi \ - src/date_sig.cmi src/calendar_builder.cmi + src/period.cmi src/date_sig.cmi src/calendar_builder.cmi src/calendar_builder.cmx: src/utils.cmx src/time_sig.cmi src/time_Zone.cmx \ - src/date_sig.cmi src/calendar_builder.cmi -src/date.cmo: src/utils.cmi src/time_Zone.cmi src/date.cmi -src/date.cmx: src/utils.cmx src/time_Zone.cmx src/date.cmi + src/period.cmi src/date_sig.cmi src/calendar_builder.cmi +src/date.cmo: src/utils.cmi src/time_Zone.cmi src/period.cmi src/date.cmi +src/date.cmx: src/utils.cmx src/time_Zone.cmx src/period.cmi src/date.cmi src/fcalendar.cmo: src/ftime.cmi src/date.cmi src/calendar_builder.cmi \ src/fcalendar.cmi src/fcalendar.cmx: src/ftime.cmx src/date.cmx src/calendar_builder.cmx \ src/fcalendar.cmi -src/ftime.cmo: src/utils.cmi src/time_Zone.cmi src/ftime.cmi -src/ftime.cmx: src/utils.cmx src/time_Zone.cmx src/ftime.cmi +src/ftime.cmo: src/utils.cmi src/time_Zone.cmi src/period.cmi src/ftime.cmi +src/ftime.cmx: src/utils.cmx src/time_Zone.cmx src/period.cmi src/ftime.cmi src/printer.cmo: src/time_Zone.cmi src/time.cmi src/period.cmi src/ftime.cmi \ src/fcalendar.cmi src/date.cmi src/calendar.cmi src/printer.cmi src/printer.cmx: src/time_Zone.cmx src/time.cmx src/period.cmi src/ftime.cmx \ src/fcalendar.cmx src/date.cmx src/calendar.cmx src/printer.cmi -src/time.cmo: src/utils.cmi src/time_Zone.cmi src/time.cmi -src/time.cmx: src/utils.cmx src/time_Zone.cmx src/time.cmi +src/time.cmo: src/utils.cmi src/time_Zone.cmi src/period.cmi src/time.cmi +src/time.cmx: src/utils.cmx src/time_Zone.cmx src/period.cmi src/time.cmi src/time_Zone.cmo: src/time_Zone.cmi src/time_Zone.cmx: src/time_Zone.cmi src/utils.cmo: src/utils.cmi @@ -1,36 +1,68 @@ -version 2.01.1, 2009-02-23: +=============================================================================== +Preliminary notes: +------------------ +Mark "o": new feature +Mark "*": bug fixed. +Mark "!": change that can break compatibility with older version of the library +=============================================================================== + +version 2.03, 2010-07-05: +========================= +* Detect whether native dynlink works (prevents compilation bug on Mac OS X) +o [Date] new function Date.precise_sub +o [Calendar] new function Calendar.precise_sub + (from Dario Teixeira's suggestion) + +version 2.02, 2009-12-11: ========================= +o [License] add the usual Ocaml linking exception in the license +o [Calendar] Calendar_sig.Period.to_time is deprecated. + Replaced by a new function Calendar_sig.Period.safe_to_time +o [Date] Date.Period.nb_days is deprecated. + Replaced by a new function Date.Period.safe_nb_days +o [Compilation] calendarLib.cmxs provided if ocaml >= 3.11 is installed + (patch of Mehdi Dogguy) +o [Date] new functions Date.make_year and Date.make_year_month +o [Date] improve memory representation of Date.Period.t +* [Compilation] remove installation of packed *.cmi +* [Compilation] bug fixed under Cygwin +* [Compilation] META files was incorrect, so "ocamlfind ocamlopt" did not work +* [Compilation] file date_sig.mli, time_sig.mli and calendar_sig.mli was not + properly linked + +version 2.01.1, 2009-02-23: +=========================== * [Date] add a missing coercion rule for months (e.g. "Date.make 2008 18 1" is now equal to "Date.make 2009 6 1") -* [Date] bug fixed in date arithmetic operations due to the missing above +* [Date] bug fixed in date arithmetic operations due to the missing above feature version 2.01, 2009-01-26: ========================= -* [Printer] new formats available for printers and parsers - o %C century: as %Y without the two last digits - o %F replace %i which is now deprecated - o %P am or pm - o %R shortcut for %H:%M - o %s number of seconds since 1970/1/1 - o %z time zone in the form +hhmm (from Warren Harris' suggestion) - o %:z time zone in the form +hh:mm (from Warren Harris' suggestion) - o %::z time zone in the form +hh:mm:ss (from Warren Harris' suggestion) - o %:::z time zone in the form +hh (from Warren Harris' suggestion) -* [Printer] new paddings available for printers - o 0 (zero): pad fields with zeroes like by default - o ^: use uppercase if possible +o [Printer] new formats available for printers and parsers + - %C century: as %Y without the two last digits + - %F replace %i which is now deprecated + - %P am or pm + - %R shortcut for %H:%M + - %s number of seconds since 1970/1/1 + - %z time zone in the form +hhmm (from Warren Harris' suggestion) + - %:z time zone in the form +hh:mm (from Warren Harris' suggestion) + - %::z time zone in the form +hh:mm:ss (from Warren Harris' suggestion) + - %:::z time zone in the form +hh (from Warren Harris' suggestion) +o [Printer] new paddings available for printers + - 0 (zero): pad fields with zeroes like by default + - ^: use uppercase if possible +o [Compilation] calendarLib.cma and calendarLib.cmxa are now installed + (Janne Hellsten and Guillaume Yziquel's suggestion) * [Tests] test suite now uses Utils.Float.equal if required (patch of Richard Jones) -* [Compilation] calendarLib.cma and calendarLib.cmxa are now installed - (Janne Hellsten and Guillaume Yziquel's suggestion) * [Compilation] small bug fixed in make install * [Compilation] support of win64 (patch of David Allsopp) version 2.0.4, 2008-07-07: ========================== +o [Printer] support of "%w" and "%V" in parsers of date from string * [Printer] bug fixed with "%j" -* [Printer] support of "%w" and "%V" in parsers of date from string version 2.0.3, 2008-05-22: ========================== @@ -49,32 +81,33 @@ version 2.0.1, 2008-02-22: version 2.0, 2008-02-08: ======================== -* [Licence] license changes from LGPLv2 to LGPLv2.1 -* [Compilation] use -pack: all modules of the library are packed inside a +o! [License] license changes from LGPLv2 to LGPLv2.1 + (from a suggestion of Hezekiah M. Carty) +o! [Compilation] use -pack: all modules of the library are packed inside a single module CalendarLib (calendar now requires ocaml >= 3.09.1) -* new modules Time_sig, Date_sig and Calendar_sig -* new module Ftime (time implementation in which seconds are floats) +o new modules Time_sig, Date_sig and Calendar_sig +o new module Ftime (time implementation in which seconds are floats) (Hezekiah M. Carty's suggestion) -* new module Calendar_builder (generic calendar implementation) -* new module Fcalendar (calendar implementation using Ftime) -* new module Calendar.Precise (calendar with a best precision) -* hash functions are provided -* [Printer] new modules Printer.Ftime and Printer.Fcalendar -* [Printer] modules Printer.Date, Printer.Time and Printer.Calendar - respectively replace Printer.DatePrinter, Printer.TimePrinter and +o new module Calendar_builder (generic calendar implementation) +o new module Fcalendar (calendar implementation using Ftime) +o new module Calendar.Precise (calendar with a best precision) +o hash functions are provided +o [Printer] new modules Printer.Ftime and Printer.Fcalendar +o [Printer] modules Printer.Date, Printer.Time and Printer.Calendar + respectively replace Printer.DatePrinter, Printer.TimePrinter and Printer.CalendarPrinter. These last modules still exist but are deprecated. -* [Time_Zone] new function Time_Zone.on -* [Date] new function Date.from_day_of_year (Hezekiah M. Carty's suggestion) -* [Date] new function Date.is_valid_date (Richard Jones' suggestion) -* new module Utils -* new module Version (information about version of calendar) -* [Documentation] add tags @example, @raise and @see in the API documentation +o [Time_Zone] new function Time_Zone.on +o [Date] new function Date.from_day_of_year (Hezekiah M. Carty's suggestion) +o [Date] new function Date.is_valid_date (Richard Jones' suggestion) +o new module Utils +o new module Version (information about version of calendar) +o [Documentation] add tags @example, @raise and @see in the API documentation version 1.10, 2007-05-14: ========================= -* [Printer] "from_fstring" in printers recognizes more formats. +o [Printer] "from_fstring" in printers recognizes more formats. (Sean Seefried's suggestion) -* [Printer] add Printer.set_word_regexp +o [Printer] add Printer.set_word_regexp version 1.09.6, 2006-07-07: =========================== @@ -87,10 +120,10 @@ version 1.09.5, 2006-05-26: version 1.09.4, 2006-02-13: =========================== -* [Printer] bug fixed in printers with %I, %l, %p and %r - (patch of Jerry Charumilind) -* [Time_Zone] add Time_Zone.is_dst and Time_Zone.hour_of_dst +o [Time_Zone] add Time_Zone.is_dst and Time_Zone.hour_of_dst (Daniel Peng's suggestion) +* [Printer] bug fixed in printers with %I, %l, %p and %r + (patch of Jerry Charumilind) * [Time_Zone] bug fixed when checking bounds in Time_Zone (patch of Daniel Peng) version 1.09.3, 2005-01-17: @@ -99,79 +132,79 @@ version 1.09.3, 2005-01-17: version 1.09.2, 2004-12-15: =========================== -* [Date] bug fixed in Date.from_unixfloat and Date.from_unixtm with +* [Date] bug fixed in Date.from_unixfloat and Date.from_unixtm with time zones <> UTC version 1.09.1, 2004-11-17: =========================== +o [Documentation] add tag @since in the API documentation * [Calendar] bug fixed in Calendar.to/from_unixfloat with time zones <> UTC -* [Documentation] add tag @since in the API documentation * [Compilation] META file is now writable version 1.09.0, 2004-11-13: =========================== -* [Date] add Date.to_business and Date.from_business (Richard Jone's suggestion) -* [Date] add the optional parameter ?month to Date.days_in_year +o [Date] add Date.to_business and Date.from_business (Richard Jone's suggestion) +o [Date] add the optional parameter ?month to Date.days_in_year (Richard Jones' suggestion) -* [Date] add Date.nth_weekday_of_month (Richard Jones' suggestion) -* [Date] Date: add some Christian dates (Richard Jones' suggestion) -* [Date] add Date.Period.ymd and Calendar.Period.ymds -* [Printer] add the format string %i corresponding to the ISO-8601 notation -* [Printer] ISO-8601 notation is now the default format -* add [equal] in all the modules +o [Date] add Date.nth_weekday_of_month (Richard Jones' suggestion) +o [Date] Date: add some Christian dates (Richard Jones' suggestion) +o [Date] add Date.Period.ymd and Calendar.Period.ymds +o [Printer] add the format string %i corresponding to the ISO-8601 notation +o add "equal" in all the modules +*! [Printer] ISO-8601 notation is now the default format * [Calendar.Period] bug fixed with negative period * [Calendar] bug fixed in Calendar.to/from_unixfloat and Date.to/from_unixfloat * [Date] bug fixed in Date.weeks_in_year version 1.08, 2004-05-18: ========================= -* [Date] add [week_first_last] computing the first and last days of a week in a +o [Date] add "week_first_last" computing the first and last days of a week in a year version 1.07, 2004-03-22: ========================= +o [Documentation] documentation of the API with ocamldoc * [Compilation] compile even if no ocaml native compiler is available (from a patch of Stefano Zacchiroli) -* [Documentation] documentation of the API with ocamldoc version 1.06, 2003-12-05: ========================= +o [Compilation] improved "make install" * [Compilation] compile with an optimized compiler (ocamlopt.opt or ocamlc.opt) if possible -* [Compilation] improved "make install" version 1.05, 2003-09-18: ========================= -* add module Printer (from a suggestion of Stefano Zacchiroli) -* remove to_string and from_string from Date, Time and Calendar +o add module Printer (from a suggestion of Stefano Zacchiroli) +o! remove to_string and from_string from Date, Time and Calendar (replaced by functions of Printer) -* Str library is no longer necessary -* add labelled version of make in Date, Time and Calendar +o Str library is no longer necessary +o add labelled version of make in Date, Time and Calendar version 1.04, 2003-08-31: ========================= -* [Period] add getters in Time.Period, Date.Period and Calendar.Period +o [Period] add getters in Time.Period, Date.Period and Calendar.Period (from a suggestion of Christoph Bauer) version 1.03, 2003-08-25: ========================= -* [Calendar] add "to_time" in Calendar (Julien Forest's suggestion) +o [Calendar] add "to_time" in Calendar (Julien Forest's suggestion) version 1.02, 2003-08-18: ========================= -* [Compilation] bug fixed in configure.in (calendar now works with +* [Compilation] bug fixed in configure.in (calendar now works with caml version > 3.06) version 1.01, 2003-07-16: ========================= -* change "minut" by "minute" -* change "egal" by "equal" -* change "GMT" by "UTC" -* add to_unixtm, from_unixtm, to_unixfloat and from_unixfloat in +o add to_unixtm, from_unixtm, to_unixfloat and from_unixfloat in Date and Calendar +*! change "minut" by "minute" +*! change "egal" by "equal" +*! change "GMT" by "UTC" (Thank's to Eric C. Cooper for those suggestions) -version 1.0, 2003-07-11: +version 1.0, 2003-07-11: ======================== -* first release +o first release @@ -1,15 +1,17 @@ Calendar library -Copyright (C) 2003-2008 Julien Signoles +Copyright (C) 2003-2009 Julien Signoles you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1 as published by the -Free Software Foundation. +Free Software Foundation, with a special linking exception (usual +for Objective Caml libraries). It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU Lesser General Public License for more details. +MERCHANTABILITY or FITNESS FOR A PARTICULAR See the GNU Lesser General Public Licence version 2.1 for more -details (enclosed in the file LGPL). +details (enclosed in the file LGPL). +The special linking exception is detailled in the enclosed file +LICENSE. @@ -1,17 +1,19 @@ -This file is part of Calendar. +This file is part of Calendar. -Copyright (C) 2003-2008 Julien Signoles +Copyright (C) 2003-2010 Julien Signoles -you can redistribute it and/or modify it under the terms of the GNU -Lesser General Public License version 2.1 as published by the -Free Software Foundation. +you can redistribute it and/or modify it under the terms of the GNU +Lesser General Public License version 2.1 as published by the +Free Software Foundation, with a special linking exception (usual +for Objective Caml libraries). It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU Lesser General Public License for more details. +MERCHANTABILITY or FITNESS FOR A PARTICULAR -See the GNU Lesser General Public Licence version 2.1 for more +See the GNU Lesser General Public Licence version 2.1 for more details (enclosed in the file LGPL). +The special linking exception is detailled in the enclosed file +LICENSE. @@ -0,0 +1,521 @@ + +=============================================================================== + + OCAML SPECIAL EXCEPTION + +As a special exception to the GNU Library General Public License, you may link, +statically or dynamically, a "work that uses the Library" with a publicly +distributed version of the Library to produce an executable file containing +portions of the Library, and distribute that executable file under terms of +your choice, without any of the additional requirements listed in clause 6 of +the GNU Library General Public License. By "a publicly distributed version of +the Library", we mean either the unmodified Library as distributed by the +original author, or a modified version of the Library that is distributed under +the conditions defined in clause 3 of the GNU Library General Public License. +This exception does not however invalidate any other reasons why the executable +file might be covered by the GNU Library General Public License. + +=============================================================================== + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + <one line to give the library's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + <signature of Ty Coon>, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/Makefile.in b/Makefile.in index 1dd40b8..1e51d37 100644 --- a/Makefile.in +++ b/Makefile.in @@ -2,24 +2,24 @@ # # # This file is part of Calendar. # # # -# Copyright (C) 2003-2008 Julien Signoles # +# Copyright (C) 2003-2010 Julien Signoles # # # # you can redistribute it and/or modify it under the terms of the GNU # # Lesser General Public License version 2.1 as published by the # -# Free Software Foundation. # +# Free Software Foundation, with a special linking exception (usual # +# for Objective Caml libraries). # # # # It is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # -# GNU Lesser General Public License for more details. # +# MERCHANTABILITY or FITNESS FOR A PARTICULAR # # # # See the GNU Lesser General Public Licence version 2.1 for more # # details (enclosed in the file LGPL). # # # +# The special linking exception is detailled in the enclosed file # +# LICENSE. # ########################################################################## -# $Id: Makefile.in,v 1.75 2009/02/23 10:33:17 signoles Exp $ - # Used programs ############### @@ -37,24 +37,29 @@ CAMLFIND= @OCAMLFIND@ OBJ_EXT = @OBJEXT@ LIB_EXT = @LIBEXT@ +HAS_NATDYNLINK=@HAS_NATDYNLINK@ + # Project ######### NAME = calendar NAMELIB = calendarLib -VERSION = 2.01.1 +VERSION = 2.03 LIBDIR = target LIBS = $(LIBDIR)/$(NAMELIB).cmo $(LIBDIR)/$(NAMELIB).cma CLIBS = ifneq ($(CAMLOPT),no) -LIBS := $(LIBS) $(LIBDIR)/$(NAMELIB).cmx $(LIBDIR)/$(NAMELIB).cmxa +LIBS := $(LIBS) $(LIBDIR)/$(NAMELIB).cmx $(LIBDIR)/$(NAMELIB).cmxa +ifeq ($(HAS_NATDYNLINK),yes) +LIBS := $(LIBS) $(LIBDIR)/$(NAMELIB).cmxs +endif CLIBS := $(CLIBS) $(LIBDIR)/$(NAMELIB)$(OBJ_EXT) \ $(LIBDIR)/$(NAMELIB)$(LIB_EXT) endif -DIRS = src +DIRS = src target tests SRC = utils.mli utils.ml time_Zone.mli time_Zone.ml period.mli \ time_sig.mli time.mli time.ml ftime.mli ftime.ml \ @@ -71,18 +76,19 @@ MLI = $(filter %.mli, $(SRC)) CMO = $(ML:.ml=.cmo) CMX = $(CMO:.cmo=.cmx) CMI = $(MLI:.mli=.cmi) -CMI_ONLY= src/period.cmi +CMI_ONLY= src/period.cmi src/date_sig.cmi src/time_sig.cmi src/calendar_sig.cmi GENERATED= src/version.ml # Libs and flags ################ -CAMLIBS = -I $(DIRS) +CAMLIBS = $(addprefix -I , $(DIRS)) CAMLFLAGS= $(CAMLIBS) BYTEFLAGS= $(CAMLFLAGS) -OPTFLAGS = $(CAMLFLAGS) -noassert +LINK_OPTFLAGS = $(CAMLFLAGS) -noassert +OPTFLAGS = $(LINK_OPTFLAGS) -for-pack CalendarLib # Main rules ############ @@ -97,15 +103,16 @@ $(LIBDIR)/$(NAMELIB).cmo: $(CMI_ONLY) $(CMO) $(LIBDIR)/$(NAMELIB).cma: $(LIBDIR)/$(NAMELIB).cmo $(CAMLFIND) ocamlc $(BYTEFLAGS) -a -o $@ $< -$(CMX):OPTFLAGS:=$(OPTFLAGS) -for-pack CalendarLib - $(LIBDIR)/$(NAMELIB).cmx: $(CMI_ONLY) $(CMX) mkdir -p $(LIBDIR) - $(CAMLFIND) ocamlopt $(OPTFLAGS) -pack -o $@ \ + $(CAMLFIND) ocamlopt $(LINK_OPTFLAGS) -pack -o $@ \ $(filter-out $(LIBDIR), $^) -$(LIBDIR)/$(NAMELIB).a $(LIBDIR)/$(NAMELIB).cmxa: $(LIBDIR)/$(NAMELIB).cmx - $(CAMLFIND) ocamlopt $(OPTFLAGS) -a -o $@ $< +$(LIBDIR)/$(NAMELIB).a $(LIBDIR)/$(NAMELIB).cmxa: $(LIBDIR)/$(NAMELIB).cmx + $(CAMLFIND) ocamlopt $(LINK_OPTFLAGS) -a -o $@ $< + +$(LIBDIR)/$(NAMELIB).cmxs: $(LIBDIR)/$(NAMELIB).cmxa + $(CAMLFIND) ocamlopt -I $(LIBDIR) -shared -linkall -o $@ $< src/version.ml: Makefile echo "let version = \"$(VERSION)\"" > $@ @@ -114,8 +121,8 @@ src/version.ml: Makefile META: Makefile echo "description = \"$(NAME) library\"" > $@ echo "version = \"$(VERSION)\"" >> $@ - echo "archive(byte) = \"$(NAMELIB).cmo $(NAMELIB).cma\"" >> $@ - echo "archive(native) = \"$(NAMELIB).cmx $(NAMELIB).cmxa\"" >> $@ + echo "archive(byte) = \"$(NAMELIB).cma\"" >> $@ + echo "archive(native) = \"$(NAMELIB).cmxa\"" >> $@ echo "requires = \"unix str\"" >> $@ # Generic rules @@ -141,21 +148,19 @@ META: Makefile # Tests ####### -TESTS = test_timezone test_time test_ftime test_date \ - test_calendar test_fcalendar test_pcalendar test_fpcalendar \ - test_printer -TESTS := $(addprefix tests/, $(TESTS)) +TESTS_SRC= gen_test.mli gen_test.ml test_timezone.ml test_time.ml \ + test_ftime.ml test_date.ml test_calendar.ml test_fcalendar.ml \ + test_pcalendar.ml test_fpcalendar.ml test_printer.ml test.ml +TESTS_SRC:= $(addprefix tests/, $(TESTS_SRC)) -TESTS_CMO= $(addsuffix .cmo, $(TESTS)) +TESTS_ML= $(filter %.ml, $(TESTS_SRC)) +TESTS_CMO= $(TESTS_ML:.ml=.cmo) -$(TESTS_CMO): tests/gen_test.cmo -tests/test.cmo: $(TESTS_CMO) +$(TESTS_CMO) $(TESTS_CMI): $(LIBDIR)/$(NAMELIB).cmo $(LIBDIR)/$(NAMELIB).cmi -tests/test: $(LIBDIR)/$(NAMELIB).cmo tests/test.cmo +tests/test: $(LIBDIR)/$(NAMELIB).cmo $(TESTS_CMO) $(CAMLC) -o $@ $(BYTEFLAGS) unix.cma str.cma $(LIBDIR)/$(NAMELIB).cmo \ - tests/gen_test.cmo $(TESTS_CMO) tests/test.cmo - -$(TESTS_CMO) tests/test.cmo: BYTEFLAGS := -I tests -I target + $(TESTS_CMO) .PHONY: tests tests: tests/test @@ -185,17 +190,18 @@ doc: $(CMO) utils/example.cmo .PHONY: headers headers: - headache -c headache_config.txt -h HEADER $(SRC) Makefile.in + headache -c headache_config.txt -h HEADER $(SRC) $(TESTS_SRC) \ + Makefile.in utils/example.ml headache -c headache_config.txt -h CONFIGURE_HEADER configure.in # Install ######### install: $(LIBS) $(CLIBS) META - @if [ "`sed -n -e 's/version = "\([0-9.]*\)"/\1/p' META`" = "$(VERSION)" ]; then \ + @if [ "`sed -n -e 's/version = "\([0-9.+dev]*\)"/\1/p' META`" = "$(VERSION)" ]; then \ (if test -d `ocamlfind install -help | grep destdir | sed -e "s/.*default: \(.*\))/\1/"`/$(NAME); then $(MAKE) uninstall; fi;\ - $(CAMLFIND) install $(NAME) target/*.cm[iox] target/*.cma target/*.cmxa $(MLI) $(CMI) $(CLIBS) META\ - )else \ + $(CAMLFIND) install $(NAME) target/*.cm[ioxa] target/*.cmx[as] $(MLI) $(CLIBS) META); \ + else \ (echo; echo "Not the good version. Please, do :"; \ echo " make clean && make"; \ echo "next reinstall"; echo) \ @@ -208,31 +214,33 @@ uninstall: ########### EXPORT_DIR= $$HOME/WWW/prog/$(NAME) -TMP_DIR = tmp +TMP_DIR = $$HOME/tmp + +ROOT= $$HOME/DEV/calendar -export: doc #$(NAME).ps.gz - cvs export -d $(TMP_DIR)/$(NAME)-$(VERSION) -D now $(NAME) +export: doc + (cd $(TMP_DIR); \ + svn co svn+ssh://signoles@svn.forge.ocamlcore.org/svnroot/calendar/trunk) + svn copy $(TMP_DIR)/trunk $(ROOT)/tags/v$(VERSION) + rm -rf $(TMP_DIR)/trunk + (cd $(ROOT)/tags; svn commit -m "v $(VERSION)") rm -rf $(EXPORT_DIR)/doc - cp -rf .depend configure config.status doc $(TMP_DIR)/$(NAME)-$(VERSION) cp -rf CHANGES doc $(EXPORT_DIR) - chmod -R ugo+r $(TMP_DIR)/$(NAME)-$(VERSION) + cp -rf $(ROOT)/tags/v$(VERSION) $(TMP_DIR)/$(NAME)-$(VERSION) + cp -rf .depend configure config.status doc $(TMP_DIR)/$(NAME)-$(VERSION) cd $(TMP_DIR); \ - (rm -f $(NAME)-$(VERSION)/html/touch-html \ - $(NAME)-$(VERSION)/.cvsignore; \ + (rm -rf $(NAME)-$(VERSION)/.svn $(NAME)-$(VERSION)/*/.svn; \ tar cvf $(NAME)-$(VERSION).tar $(NAME)-$(VERSION); \ gzip -f --best $(NAME)-$(VERSION).tar; \ rm -rf $(NAME)-$(VERSION); \ mv $(NAME)-$(VERSION).tar.gz $(EXPORT_DIR)) -# cd $(EXPORT_DIR)/../..; \ -# (sed -e "s/_CALVERS_/$(VERSION)/" misc/bindings.dat.pre \ -# > misc/bindings.dat; \ -# ./scripts/create_html.sh) + rm -rf $(TMP_DIR)/$(NAME)-$(VERSION) # Rebuilding Makefile ##################### Makefile: Makefile.in - ./config.status + ./config.status config.status: configure ./config.status --recheck @@ -250,7 +258,7 @@ TAGS: $(SRC) ########## clean: - rm -f TAGS META $(TESTS) tests/test $(GENERATED) + rm -f TAGS META $(TESTS) tests/test $(GENERATED) for i in . src tests utils; do \ rm -f $$i/*~ $$i/\#* $$i/*.cm[iox] $$i/*.*a $$i/*$(OBJ_EXT) $$i/a.out; \ done @@ -266,9 +274,8 @@ clean-configure cleanconfig: dist-clean .depend depend: $(GENERATED) rm -f .depend - for i in src tests; do \ - $(CAMLDEP) $(CAMLIBS) -I tests $$i/*.ml $$i/*.mli; \ - done > .depend + $(CAMLDEP) -I src -I tests src/*.ml src/*.mli tests/*.ml tests/*.mli \ + > .depend view-depend: $(CAMLDOT) .depend | dot -Tps | gv - @@ -17,7 +17,7 @@ The Calendar library is a library providing a set of operations over dates and times. This library requires Objective Caml (OCaml) 3.09.1 or higher. OCaml 3.09 is usable at your own risks. -Older OCaml version are unsupported. +Older OCaml versions are unsupported. 2- Contents ----------- @@ -86,7 +86,7 @@ or The doc directory contains an html documentation of the .mli files. This documentation is available online at - http://www.lri.fr/~signoles/prog/calendar/doc + http://calendar.forge.ocamlcore.org/doc/ 7- Makefile ----------- @@ -99,13 +99,10 @@ Execute some tests ii. wc Give informations about the size of the source files. You need ocamlwc (*). -iii. calendar.ps.gz -Same as above. Moreover the documentation is zipped. - -iv. doc +iii. doc Produce the documentation of the API. You need ocamldoc (**). -(*) ocamlwc is available at http://www.lri.fr/~filliatr/software.en.html +(*) ocamlwc is available at http://www.lri.fr/~filliatr/software.en.html (**) ocamldoc is included with Objective Caml 8- Contact the developper @@ -113,4 +110,4 @@ Produce the documentation of the API. You need ocamldoc (**). You can report bugs and/or give feedbacks by e-mail to : - Julien.Signoles@cea.fr + Julien.Signoles@NO_SPAM@gmail.com @@ -1,40 +1,3 @@ -* intégrer les nouvelles options de date (date --help) - %g: 2 derniers chiffres de l'année correspondant au numéro de semaine ISO - %G: année correspondant au numéro de semaine ISO (utile avec %V seulement) - %N: nanosecondes (000000000..999999999) - %u: jour de la semaine 1..7, 1=lundi - %U: numéro de la semaine dans l'année débutant par le dimanche - comme premier jour de la semaine (00..53) - %V: le numéro de la semaine ISO dans l'année débutant par le lundi - comme premier jour de la semaine (01..53) - [soit %V, soit %W a changé de spec] - %w: le jour de la semaine (0..6); 0 représente le dimanche - [changement de spec] - %W: le numéro de la semaine dans l'année débutant par le lundi - comme premier jour de la semaine (00..53) - [soit %V, soit %W a changé de spec] - %Z: abréviation alphabétique des fuseaux horaires (i.e. EDT) - tags: - #: casse opposée si possible - nombre possible après un tag pour indiquer la largeur du champ - (en fait, largeur champ = max entre nombre indiqué et place requise) -* printing float seconds (suggestion de Warren Harris) - ==> %N -* ajouter AC ou BC dans le printer. - Plus généralement, bien afficher les dates avant JC -* lever limitation intervalles de date (suggestion de Warren Harris) -* pouvoir gérer facilement les dates moins précises (sans jour ou mois exprimé) - (suggestion de Warren Harris). Extensible aux temps et aux calendriers -* mieux préciser différences version Precise vs standart, en particulier - connaître "the range and precision of each representation" - (suggestion de Warren Harris) -* constructeurs safe et "unsafe" (pour Date, Time et Calendar) -* constructeurs prenant le mois sous forme de month (et non de int) en param -* ouvrir la porte à de nouveaux calendriers en codant plusieurs implantations - de Date basés sur divers calendrier (avec signature commune) et en ayant une - version fonctorielle des modules basés sur Date (comme Calendar ou - DatePrinter). - Mettre alors en place des conversions inter-calendrier (de grégorien vers - julien et vice-versa, etc). -* adapter par rapport à la nouvelle FAQ et aux fichiers .ps -* permettre le native dynlink de calendar + +Not used anymore. +See http://forge.ocamlcore.org/pm/?group_id=83 diff --git a/config.status b/config.status index de86a32..062856e 100755 --- a/config.status +++ b/config.status @@ -7,56 +7,77 @@ debug=false ac_cs_recheck=false ac_cs_silent=false + SHELL=${CONFIG_SHELL-/bin/bash} -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## +export SHELL +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; esac - fi - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' else - PATH_SEPARATOR=: + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' fi - rm -f conf$$.sh + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' fi -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } fi @@ -65,20 +86,18 @@ fi # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) -as_nl=' -' IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. -case $0 in +case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done IFS=$as_save_IFS ;; @@ -89,32 +108,111 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 fi -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error ERROR [LINENO LOG_FD] +# --------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with status $?, using 1 if that was 0. +as_fn_error () +{ + as_status=$?; test $as_status -eq 0 && as_status=1 + if test "$3"; then + as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3 fi -done + $as_echo "$as_me: error: $1" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + -# Required to use basename. if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr @@ -128,13 +226,17 @@ else as_basename=false fi +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi -# Name of the executable. as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | +$as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -149,104 +251,103 @@ echo X/"$0" | } s/.*/./; q'` -# CDPATH. -$as_unset CDPATH - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in +case `echo -n x` in #((((( -n*) - case `echo 'x\c'` in + case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir - mkdir conf$$.dir + mkdir conf$$.dir 2>/dev/null fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -p'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -p' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln + fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir" + + +} # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then - as_mkdir_p=: + as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false @@ -263,12 +364,12 @@ else as_test_x=' eval sh -c '\'' if test -d "$1"; then - test -d "$1/."; + test -d "$1/."; else - case $1 in - -*)set "./$1";; + case $1 in #( + -*)set "./$1";; esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in + case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' @@ -283,13 +384,15 @@ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 - -# Save the log message, to keep $[0] and so on meaningful, and to +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +# Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by $as_me, which was -generated by GNU Autoconf 2.61. Invocation command line was +generated by GNU Autoconf 2.64. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -304,37 +407,39 @@ on `(hostname || uname -n) 2>/dev/null | sed 1q` config_files=" Makefile" ac_cs_usage="\ -\`$as_me' instantiates files from templates according to the -current configuration. +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. -Usage: $0 [OPTIONS] [FILE]... +Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit - -q, --quiet do not print progress messages + -q, --quiet, --silent + do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions - --file=FILE[:TEMPLATE] - instantiate the configuration file FILE + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE Configuration files: $config_files -Report bugs to <bug-autoconf@gnu.org>." +Report bugs to the package provider." ac_cs_version="\ config.status -configured by ./configure, generated by GNU Autoconf 2.61, +configured by ./configure, generated by GNU Autoconf 2.64, with options \"\" -Copyright (C) 2006 Free Software Foundation, Inc. +Copyright (C) 2009 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." -ac_pwd='/home/jsignole/dev/calendar' +ac_pwd='/localhome/julien/DEV/calendar/trunk' srcdir='.' -# If no file are specified by the user, then we need to provide default -# value. By we need to know if files were specified by the user. +test -n "$AWK" || AWK=awk +# The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do @@ -356,25 +461,27 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - echo "$ac_cs_version"; exit ;; + $as_echo "$ac_cs_version"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift - CONFIG_FILES="$CONFIG_FILES $ac_optarg" + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) - echo "$ac_cs_usage"; exit ;; + $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. - -*) { echo "$as_me: error: unrecognized option: $1 -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } ;; + -*) as_fn_error "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; - *) ac_config_targets="$ac_config_targets $1" + *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac @@ -389,10 +496,12 @@ if $ac_cs_silent; then fi if $ac_cs_recheck; then - echo "running CONFIG_SHELL=/bin/bash /bin/bash ./configure " $ac_configure_extra_args " --no-create --no-recursion" >&6 - CONFIG_SHELL=/bin/bash + set X '/bin/bash' './configure' $ac_configure_extra_args --no-create --no-recursion + shift + $as_echo "running CONFIG_SHELL=/bin/bash $*" >&6 + CONFIG_SHELL='/bin/bash' export CONFIG_SHELL - exec /bin/bash "./configure" $ac_configure_extra_args --no-create --no-recursion + exec "$@" fi exec 5>>config.log @@ -401,7 +510,7 @@ exec 5>>config.log sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX - echo "$ac_log" + $as_echo "$ac_log" } >&5 @@ -411,9 +520,7 @@ do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; - *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 -echo "$as_me: error: invalid argument: $ac_config_target" >&2;} - { (exit 1); exit 1; }; };; + *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done @@ -438,7 +545,7 @@ $debug || trap 'exit_status=$? { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status ' 0 - trap '{ (exit 1); exit 1; }' 1 2 13 15 + trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. @@ -449,92 +556,132 @@ $debug || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") -} || -{ - echo "$me: cannot create a temporary directory in ." >&2 - { (exit 1); exit 1; } -} - -# -# Set up the sed scripts for CONFIG_FILES section. -# +} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5 -# No need to generate the scripts if there are no CONFIG_FILES. -# This happens for instance when ./config.status config.h +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then -cat >"$tmp/subs-1.sed" <<\CEOF -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end -s,@SHELL@,|#_!!_#|/bin/bash,g -s,@PATH_SEPARATOR@,|#_!!_#|:,g -s,@PACKAGE_NAME@,|#_!!_#|,g -s,@PACKAGE_TARNAME@,|#_!!_#|,g -s,@PACKAGE_VERSION@,|#_!!_#|,g -s,@PACKAGE_STRING@,|#_!!_#|,g -s,@PACKAGE_BUGREPORT@,|#_!!_#|,g -s,@exec_prefix@,|#_!!_#|${prefix},g -s,@prefix@,|#_!!_#|/usr/local,g -s,@program_transform_name@,|#_!!_#|s\,x\,x\,,g -s,@bindir@,|#_!!_#|${exec_prefix}/bin,g -s,@sbindir@,|#_!!_#|${exec_prefix}/sbin,g -s,@libexecdir@,|#_!!_#|${exec_prefix}/libexec,g -s,@datarootdir@,|#_!!_#|${prefix}/share,g -s,@datadir@,|#_!!_#|${datarootdir},g -s,@sysconfdir@,|#_!!_#|${prefix}/etc,g -s,@sharedstatedir@,|#_!!_#|${prefix}/com,g -s,@localstatedir@,|#_!!_#|${prefix}/var,g -s,@includedir@,|#_!!_#|${prefix}/include,g -s,@oldincludedir@,|#_!!_#|/usr/include,g -s,@docdir@,|#_!!_#|${datarootdir}/doc/${PACKAGE},g -s,@infodir@,|#_!!_#|${datarootdir}/info,g -s,@htmldir@,|#_!!_#|${docdir},g -s,@dvidir@,|#_!!_#|${docdir},g -s,@pdfdir@,|#_!!_#|${docdir},g -s,@psdir@,|#_!!_#|${docdir},g -s,@libdir@,|#_!!_#|${exec_prefix}/lib,g -s,@localedir@,|#_!!_#|${datarootdir}/locale,g -s,@mandir@,|#_!!_#|${datarootdir}/man,g -s,@DEFS@,|#_!!_#|-DPACKAGE_NAME=\\"\\" -DPACKAGE_TARNAME=\\"\\" -DPACKAGE_VERSION=\\"\\" -DPACKAGE_STRING=\\"\\" -DPACKAGE_BUGREPORT=\\"\\",g -s,@ECHO_C@,|#_!!_#|,g -s,@ECHO_N@,|#_!!_#|-n,g -s,@ECHO_T@,|#_!!_#|,g -s,@LIBS@,|#_!!_#|,g -s,@build_alias@,|#_!!_#|,g -s,@host_alias@,|#_!!_#|,g -s,@target_alias@,|#_!!_#|,g -s,@OCAMLC@,|#_!!_#|ocamlc.opt,g -s,@OCAMLOPT@,|#_!!_#|ocamlopt.opt,g -s,@OCAMLCDOTOPT@,|#_!!_#|ocamlc.opt,g -s,@OCAMLOPTDOTOPT@,|#_!!_#|ocamlopt.opt,g -s,@OCAMLDEP@,|#_!!_#|ocamldep,g -s,@OCAMLFIND@,|#_!!_#|ocamlfind,g -s,@OCAMLDOC@,|#_!!_#|ocamldoc,g -s,@OCAMLWEB@,|#_!!_#|ocamlweb,g -s,@OCAMLWC@,|#_!!_#|ocamlwc,g -s,@OCAMLDOT@,|#_!!_#|true,g -s,@OCAMLBEST@,|#_!!_#|opt,g -s,@OCAMLVERSION@,|#_!!_#|3.11.0,g -s,@OCAMLLIB@,|#_!!_#|/home/jsignole/local/godi/lib/ocaml/std-lib,g -s,@OBJEXT@,|#_!!_#|.o,g -s,@LIBEXT@,|#_!!_#|.a,g -s,@LIBOBJS@,|#_!!_#|,g -s,@LTLIBOBJS@,|#_!!_#|,g -:end -s/|#_!!_#|//g -CEOF + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$tmp/subs1.awk" && +cat >>"$tmp/subs1.awk" <<\_ACAWK && +S["LTLIBOBJS"]="" +S["LIBOBJS"]="" +S["HAS_NATDYNLINK"]="yes" +S["LIBEXT"]=".a" +S["OBJEXT"]=".o" +S["OCAMLLIB"]="/localhome/julien/godi/lib/ocaml/std-lib" +S["OCAMLVERSION"]="3.11.2" +S["OCAMLBEST"]="opt" +S["OCAMLDOT"]="ocamldot" +S["OCAMLWC"]="ocamlwc" +S["OCAMLWEB"]="ocamlweb" +S["OCAMLDOC"]="ocamldoc" +S["OCAMLFIND"]="ocamlfind" +S["OCAMLDEP"]="ocamldep" +S["OCAMLOPTDOTOPT"]="ocamlopt.opt" +S["OCAMLCDOTOPT"]="ocamlc.opt" +S["OCAMLOPT"]="ocamlopt.opt" +S["OCAMLC"]="ocamlc.opt" +S["target_alias"]="" +S["host_alias"]="" +S["build_alias"]="" +S["LIBS"]="" +S["ECHO_T"]="" +S["ECHO_N"]="-n" +S["ECHO_C"]="" +S["DEFS"]="-DPACKAGE_NAME=\\\"\\\" -DPACKAGE_TARNAME=\\\"\\\" -DPACKAGE_VERSION=\\\"\\\" -DPACKAGE_STRING=\\\"\\\" -DPACKAGE_BUGREPORT=\\\"\\\" -DPACKAGE_URL=\\\"\\\"" +S["mandir"]="${datarootdir}/man" +S["localedir"]="${datarootdir}/locale" +S["libdir"]="${exec_prefix}/lib" +S["psdir"]="${docdir}" +S["pdfdir"]="${docdir}" +S["dvidir"]="${docdir}" +S["htmldir"]="${docdir}" +S["infodir"]="${datarootdir}/info" +S["docdir"]="${datarootdir}/doc/${PACKAGE}" +S["oldincludedir"]="/usr/include" +S["includedir"]="${prefix}/include" +S["localstatedir"]="${prefix}/var" +S["sharedstatedir"]="${prefix}/com" +S["sysconfdir"]="${prefix}/etc" +S["datadir"]="${datarootdir}" +S["datarootdir"]="${prefix}/share" +S["libexecdir"]="${exec_prefix}/libexec" +S["sbindir"]="${exec_prefix}/sbin" +S["bindir"]="${exec_prefix}/bin" +S["program_transform_name"]="s,x,x," +S["prefix"]="/usr/local" +S["exec_prefix"]="${prefix}" +S["PACKAGE_URL"]="" +S["PACKAGE_BUGREPORT"]="" +S["PACKAGE_STRING"]="" +S["PACKAGE_VERSION"]="" +S["PACKAGE_TARNAME"]="" +S["PACKAGE_NAME"]="" +S["PATH_SEPARATOR"]=":" +S["SHELL"]="/bin/bash" +_ACAWK +cat >>"$tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ + || as_fn_error "could not setup config files machinery" "$LINENO" 5 fi # test -n "$CONFIG_FILES" -for ac_tag in :F $CONFIG_FILES +eval set X " :F $CONFIG_FILES " +shift +for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5 -echo "$as_me: error: Invalid tag $ac_tag." >&2;} - { (exit 1); exit 1; }; };; + :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -562,26 +709,34 @@ echo "$as_me: error: Invalid tag $ac_tag." >&2;} [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5 -echo "$as_me: error: cannot find input file: $ac_f" >&2;} - { (exit 1); exit 1; }; };; + as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac - ac_file_inputs="$ac_file_inputs $ac_f" + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ - configure_input="Generated from "`IFS=: - echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure." + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin";; + *:-:* | *:-) cat >"$tmp/stdin" \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac @@ -591,7 +746,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -echo X"$ac_file" | +$as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -609,55 +764,15 @@ echo X"$ac_file" | q } s/.*/./; q'` - { as_dir="$ac_dir" - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } + as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -694,8 +809,8 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= - -case `sed -n '/datarootdir/ { +ac_sed_dataroot=' +/datarootdir/ { p q } @@ -703,21 +818,21 @@ case `sed -n '/datarootdir/ { /@docdir@/p /@infodir@/p /@localedir@/p -/@mandir@/p -' $ac_file_inputs` in +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} ac_datarootdir_hack=' s&@datadir@&${datarootdir}&g s&@docdir@&${datarootdir}/doc/${PACKAGE}&g s&@infodir@&${datarootdir}/info&g s&@localedir@&${datarootdir}/locale&g s&@mandir@&${datarootdir}/man&g - s&\${datarootdir}&${prefix}/share&g' ;; + s&\${datarootdir}&${prefix}/share&g' ;; esac - sed "/^[ ]*VPATH[ ]*=/{ +ac_sed_extra="/^[ ]*VPATH[ ]*=/{ s/:*\$(srcdir):*/:/ s/:*\${srcdir}:*/:/ s/:*@srcdir@:*/:/ @@ -728,8 +843,9 @@ s/^[^=]*=[ ]*$// :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b -s&@configure_input@&$configure_input&;t t +s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t @@ -738,21 +854,24 @@ s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack -" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir' + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&5 -echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&2;} rm -f "$tmp/stdin" case $ac_file in - -) cat "$tmp/out"; rm -f "$tmp/out";; - *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;; - esac + -) cat "$tmp/out" && rm -f "$tmp/out";; + *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; + esac \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; @@ -762,4 +881,4 @@ which seems to be undefined. Please make sure it is defined." >&2;} done # for ac_tag -{ (exit 0); exit 0; } +as_fn_exit 0 @@ -1,60 +1,81 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.61. +# Generated by GNU Autoconf 2.64. # # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. +# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software +# Foundation, Inc. +# # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; esac - fi - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' else - PATH_SEPARATOR=: + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' fi - rm -f conf$$.sh + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' fi -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } fi @@ -63,20 +84,18 @@ fi # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) -as_nl=' -' IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. -case $0 in +case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done IFS=$as_save_IFS ;; @@ -87,354 +106,320 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 fi -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - fi -done - -# Required to use basename. -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - - -# Name of the executable. -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE # CDPATH. -$as_unset CDPATH - +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH if test "x$CONFIG_SHELL" = x; then - if (eval ":") 2>/dev/null; then - as_have_required=yes + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST else - as_have_required=no + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac fi - - if test $as_have_required = yes && (eval ": -(as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : else - exitcode=1 - echo as_func_ret_success failed. + exitcode=1; echo positional parameters were not saved. fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : +test x\$exitcode = x0 || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes else - exitcode=1 - echo positional parameters were not saved. + as_have_required=no fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : -test \$exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=\$LINENO - as_lineno_2=\$LINENO - test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" && - test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; } -") 2> /dev/null; then - : -else - as_candidate_shells= - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - case $as_dir in + as_found=: + case $as_dir in #( /*) for as_base in sh bash ksh sh5; do - as_candidate_shells="$as_candidate_shells $as_dir/$as_base" + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi done;; esac + as_found=false done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } IFS=$as_save_IFS - for as_shell in $as_candidate_shells $SHELL; do - # Try only shells that exist, to save several forks. - if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { ("$as_shell") 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - + if test "x$CONFIG_SHELL" != x; then : + # We cannot yet assume a decent shell, so we have to provide a + # neutralization value for shells without unset; and this also + # works around shells that cannot unset nonexistent variables. + BASH_ENV=/dev/null + ENV=/dev/null + (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} fi - -: -_ASEOF -}; then - CONFIG_SHELL=$as_shell - as_have_required=yes - if { "$as_shell" 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS - -: -(as_func_return () { - (exit $1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} } +as_unset=as_fn_unset -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ -if as_func_ret_success; then - : + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = "$1" ); then - : + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' else - exitcode=1 - echo positional parameters were not saved. -fi - -test $exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; } - -_ASEOF -}; then - break -fi - -fi - - done - - if test "x$CONFIG_SHELL" != x; then - for as_var in BASH_ENV ENV - do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - done - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} -fi - - - if test $as_have_required = no; then - echo This script requires a shell more modern than all the - echo shells that I found on your system. Please install a - echo modern shell, or manually run the script under such a - echo shell if you do have one. - { (exit 1); exit 1; } -fi - - -fi - -fi - + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith -(eval "as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} +# as_fn_error ERROR [LINENO LOG_FD] +# --------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with status $?, using 1 if that was 0. +as_fn_error () +{ + as_status=$?; test $as_status -eq 0 && as_status=1 + if test "$3"; then + as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3 + fi + $as_echo "$as_me: error: $1" >&2 + as_fn_exit $as_status +} # as_fn_error -exitcode=0 -if as_func_success; then - : +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. + as_expr=false fi -if as_func_ret_success; then - : +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. + as_basename=false fi -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname else - exitcode=1 - echo positional parameters were not saved. + as_dirname=false fi -test \$exitcode = 0") || { - echo No shell found that supports shell functions. - echo Please tell autoconf@gnu.org about your system, - echo including any error possibly output before this - echo message -} - +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= @@ -451,8 +436,7 @@ test \$exitcode = 0") || { s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the @@ -462,49 +446,40 @@ test \$exitcode = 0") || { exit } - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in +case `echo -n x` in #((((( -n*) - case `echo 'x\c'` in + case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -p'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -p' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln + fi else as_ln_s='cp -p' fi @@ -512,7 +487,7 @@ rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then - as_mkdir_p=: + as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false @@ -529,12 +504,12 @@ else as_test_x=' eval sh -c '\'' if test -d "$1"; then - test -d "$1/."; + test -d "$1/."; else - case $1 in - -*)set "./$1";; + case $1 in #( + -*)set "./$1";; esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in + case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' @@ -548,7 +523,6 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - exec 7<&0 </dev/null 6>&1 # Name of the host. @@ -567,7 +541,6 @@ cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= -SHELL=${CONFIG_SHELL-/bin/sh} # Identity of this package. PACKAGE_NAME= @@ -575,63 +548,69 @@ PACKAGE_TARNAME= PACKAGE_VERSION= PACKAGE_STRING= PACKAGE_BUGREPORT= +PACKAGE_URL= ac_unique_file="src/date.ml" -ac_subst_vars='SHELL -PATH_SEPARATOR -PACKAGE_NAME -PACKAGE_TARNAME -PACKAGE_VERSION -PACKAGE_STRING -PACKAGE_BUGREPORT -exec_prefix -prefix -program_transform_name -bindir -sbindir -libexecdir -datarootdir -datadir -sysconfdir -sharedstatedir -localstatedir -includedir -oldincludedir -docdir -infodir -htmldir -dvidir -pdfdir -psdir -libdir -localedir -mandir -DEFS -ECHO_C -ECHO_N -ECHO_T -LIBS -build_alias -host_alias -target_alias -OCAMLC -OCAMLOPT -OCAMLCDOTOPT -OCAMLOPTDOTOPT -OCAMLDEP -OCAMLFIND -OCAMLDOC -OCAMLWEB -OCAMLWC -OCAMLDOT -OCAMLBEST -OCAMLVERSION -OCAMLLIB -OBJEXT -LIBEXT +ac_subst_vars='LTLIBOBJS LIBOBJS -LTLIBOBJS' +HAS_NATDYNLINK +LIBEXT +OBJEXT +OCAMLLIB +OCAMLVERSION +OCAMLBEST +OCAMLDOT +OCAMLWC +OCAMLWEB +OCAMLDOC +OCAMLFIND +OCAMLDEP +OCAMLOPTDOTOPT +OCAMLCDOTOPT +OCAMLOPT +OCAMLC +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' ac_subst_files='' +ac_user_opts=' +enable_option_checking +' ac_precious_vars='build_alias host_alias target_alias' @@ -640,6 +619,8 @@ target_alias' # Initialize some variables set by options. ac_init_help= ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null @@ -738,13 +719,20 @@ do datarootdir=$ac_optarg ;; -disable-* | --disable-*) - ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=no ;; + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; @@ -757,13 +745,20 @@ do dvidir=$ac_optarg ;; -enable-* | --enable-*) - ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=\$ac_optarg ;; + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ @@ -954,22 +949,36 @@ do ac_init_version=: ;; -with-* | --with-*) - ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=\$ac_optarg ;; + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) - ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=no ;; + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. @@ -989,25 +998,25 @@ do | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; - -*) { echo "$as_me: error: unrecognized option: $ac_option -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } + -*) as_fn_error "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information." ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. - expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 - { (exit 1); exit 1; }; } + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error "invalid variable name: \`$ac_envvar'" ;; + esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. - echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} ;; @@ -1016,23 +1025,36 @@ done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` - { echo "$as_me: error: missing argument to $ac_option" >&2 - { (exit 1); exit 1; }; } + as_fn_error "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac fi -# Be sure to have absolute directory names. +# Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac - { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 - { (exit 1); exit 1; }; } + as_fn_error "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' @@ -1046,7 +1068,7 @@ target=$target_alias if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe - echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. + $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. If a cross compiler is detected then cross compile mode will be used." >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes @@ -1062,23 +1084,21 @@ test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || - { echo "$as_me: error: Working directory cannot be determined" >&2 - { (exit 1); exit 1; }; } + as_fn_error "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || - { echo "$as_me: error: pwd does not report name of working directory" >&2 - { (exit 1); exit 1; }; } + as_fn_error "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. - ac_confdir=`$as_dirname -- "$0" || -$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$0" : 'X\(//\)[^/]' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X"$0" | + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -1105,13 +1125,11 @@ else fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." - { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 - { (exit 1); exit 1; }; } + as_fn_error "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( - cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2 - { (exit 1); exit 1; }; } + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then @@ -1159,9 +1177,9 @@ Configuration: Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX - [$ac_default_prefix] + [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX - [PREFIX] + [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify @@ -1171,25 +1189,25 @@ for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: - --bindir=DIR user executables [EPREFIX/bin] - --sbindir=DIR system admin executables [EPREFIX/sbin] - --libexecdir=DIR program executables [EPREFIX/libexec] - --sysconfdir=DIR read-only single-machine data [PREFIX/etc] - --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] - --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --libdir=DIR object code libraries [EPREFIX/lib] - --includedir=DIR C header files [PREFIX/include] - --oldincludedir=DIR C header files for non-gcc [/usr/include] - --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] - --datadir=DIR read-only architecture-independent data [DATAROOTDIR] - --infodir=DIR info documentation [DATAROOTDIR/info] - --localedir=DIR locale-dependent data [DATAROOTDIR/locale] - --mandir=DIR man documentation [DATAROOTDIR/man] - --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE] - --htmldir=DIR html documentation [DOCDIR] - --dvidir=DIR dvi documentation [DOCDIR] - --pdfdir=DIR pdf documentation [DOCDIR] - --psdir=DIR ps documentation [DOCDIR] + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF @@ -1200,6 +1218,7 @@ if test -n "$ac_init_help"; then cat <<\_ACEOF +Report bugs to the package provider. _ACEOF ac_status=$? fi @@ -1207,15 +1226,17 @@ fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue - test -d "$ac_dir" || continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -1251,7 +1272,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix echo && $SHELL "$ac_srcdir/configure" --help=recursive else - echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done @@ -1261,21 +1282,24 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF configure -generated by GNU Autoconf 2.61 +generated by GNU Autoconf 2.64 -Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. +Copyright (C) 2009 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by $as_me, which was -generated by GNU Autoconf 2.61. Invocation command line was +generated by GNU Autoconf 2.64. Invocation command line was $ $0 $@ @@ -1311,8 +1335,8 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - echo "PATH: $as_dir" -done + $as_echo "PATH: $as_dir" + done IFS=$as_save_IFS } >&5 @@ -1346,12 +1370,12 @@ do | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) - ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in - 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) - ac_configure_args1="$ac_configure_args1 '$ac_arg'" + as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else @@ -1367,13 +1391,13 @@ do -* ) ac_must_keep_next=true ;; esac fi - ac_configure_args="$ac_configure_args '$ac_arg'" + as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done -$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } -$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there @@ -1398,12 +1422,13 @@ _ASBOX case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done @@ -1432,9 +1457,9 @@ _ASBOX do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - echo "$ac_var='\''$ac_val'\''" + $as_echo "$ac_var='\''$ac_val'\''" done | sort echo @@ -1449,9 +1474,9 @@ _ASBOX do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - echo "$ac_var='\''$ac_val'\''" + $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi @@ -1467,64 +1492,69 @@ _ASBOX echo fi test "$ac_signal" != 0 && - echo "$as_me: caught signal $ac_signal" - echo "$as_me: exit $exit_status" + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do - trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h +$as_echo "/* confdefs.h */" > confdefs.h + # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF - cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF - cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF - cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF - cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + # Let the site file select an alternate cache file if it wants to. -# Prefer explicitly selected file to automatically selected ones. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE if test -n "$CONFIG_SITE"; then - set x "$CONFIG_SITE" + ac_site_file1=$CONFIG_SITE elif test "x$prefix" != xNONE; then - set x "$prefix/share/config.site" "$prefix/etc/config.site" + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site else - set x "$ac_default_prefix/share/config.site" \ - "$ac_default_prefix/etc/config.site" + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site fi -shift -for ac_site_file +for ac_site_file in "$ac_site_file1" "$ac_site_file2" do + test "x$ac_site_file" = xNONE && continue if test -r "$ac_site_file"; then - { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 -echo "$as_me: loading site script $ac_site_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" fi @@ -1534,16 +1564,16 @@ if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special # files actually), so we avoid doing that. if test -f "$cache_file"; then - { echo "$as_me:$LINENO: loading cache $cache_file" >&5 -echo "$as_me: loading cache $cache_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else - { echo "$as_me:$LINENO: creating cache $cache_file" >&5 -echo "$as_me: creating cache $cache_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi @@ -1557,60 +1587,56 @@ for ac_var in $ac_precious_vars; do eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) - { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) - { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then - { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 -echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 -echo "$as_me: former value: $ac_old_val" >&2;} - { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 -echo "$as_me: current value: $ac_new_val" >&2;} - ac_cache_corrupted=: + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in - *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; + *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then - { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 -echo "$as_me: error: changes in the environment can compromise the build" >&2;} - { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 -echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} - { (exit 1); exit 1; }; } + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi - - - - - - - - - - - - - - - - +## -------------------- ## +## Main body of script. ## +## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' @@ -1625,10 +1651,10 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu # we first look for ocamlc in the path; if not present, we fail # Extract the first word of "ocamlc", so it can be a program name with args. set dummy ocamlc; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLC+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLC+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLC"; then ac_cv_prog_OCAMLC="$OCAMLC" # Let the user override the test. @@ -1638,14 +1664,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLC="ocamlc" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLC" && ac_cv_prog_OCAMLC="no" @@ -1653,18 +1679,16 @@ fi fi OCAMLC=$ac_cv_prog_OCAMLC if test -n "$OCAMLC"; then - { echo "$as_me:$LINENO: result: $OCAMLC" >&5 -echo "${ECHO_T}$OCAMLC" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLC" >&5 +$as_echo "$OCAMLC" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLC" = no ; then - { { echo "$as_me:$LINENO: error: Cannot find ocamlc." >&5 -echo "$as_me: error: Cannot find ocamlc." >&2;} - { (exit 1); exit 1; }; } + as_fn_error "Cannot find ocamlc." "$LINENO" 5 fi # we extract Ocaml version number and library path: ocaml 3.09.1 is required @@ -1678,7 +1702,7 @@ case $OCAMLVERSION in *) echo "${ECHO_T}Unsupported version!"; exit 2;; esac -OCAMLLIB=`$OCAMLC -where` +OCAMLLIB=`$OCAMLC -where | tr -d '\r'` echo "ocaml library path is $OCAMLLIB" # then we look for ocamlopt; if not present, we issue a warning @@ -1686,10 +1710,10 @@ echo "ocaml library path is $OCAMLLIB" # we set OCAMLBEST to "opt" or "byte", whether ocamlopt is available or not # Extract the first word of "ocamlopt", so it can be a program name with args. set dummy ocamlopt; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLOPT+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLOPT+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPT"; then ac_cv_prog_OCAMLOPT="$OCAMLOPT" # Let the user override the test. @@ -1699,14 +1723,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLOPT="ocamlopt" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLOPT" && ac_cv_prog_OCAMLOPT="no" @@ -1714,29 +1738,29 @@ fi fi OCAMLOPT=$ac_cv_prog_OCAMLOPT if test -n "$OCAMLOPT"; then - { echo "$as_me:$LINENO: result: $OCAMLOPT" >&5 -echo "${ECHO_T}$OCAMLOPT" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLOPT" >&5 +$as_echo "$OCAMLOPT" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi OCAMLBEST=byte if test "$OCAMLOPT" = no ; then - { echo "$as_me:$LINENO: WARNING: Cannot find ocamlopt; bytecode compilation only." >&5 -echo "$as_me: WARNING: Cannot find ocamlopt; bytecode compilation only." >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Cannot find ocamlopt; bytecode compilation only." >&5 +$as_echo "$as_me: WARNING: Cannot find ocamlopt; bytecode compilation only." >&2;} else - { echo "$as_me:$LINENO: checking ocamlopt version" >&5 -echo $ECHO_N "checking ocamlopt version... $ECHO_C" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking ocamlopt version" >&5 +$as_echo_n "checking ocamlopt version... " >&6; } TMPVERSION=`$OCAMLOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' ` if test "$TMPVERSION" != "$OCAMLVERSION" ; then - { echo "$as_me:$LINENO: result: differs from ocamlc; ocamlopt discarded." >&5 -echo "${ECHO_T}differs from ocamlc; ocamlopt discarded." >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: differs from ocamlc; ocamlopt discarded." >&5 +$as_echo "differs from ocamlc; ocamlopt discarded." >&6; } OCAMLOPT=no else - { echo "$as_me:$LINENO: result: ok" >&5 -echo "${ECHO_T}ok" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } OCAMLBEST=opt fi fi @@ -1744,10 +1768,10 @@ fi # checking for ocamlc.opt # Extract the first word of "ocamlc.opt", so it can be a program name with args. set dummy ocamlc.opt; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLCDOTOPT+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLCDOTOPT+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLCDOTOPT"; then ac_cv_prog_OCAMLCDOTOPT="$OCAMLCDOTOPT" # Let the user override the test. @@ -1757,14 +1781,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLCDOTOPT="ocamlc.opt" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLCDOTOPT" && ac_cv_prog_OCAMLCDOTOPT="no" @@ -1772,24 +1796,24 @@ fi fi OCAMLCDOTOPT=$ac_cv_prog_OCAMLCDOTOPT if test -n "$OCAMLCDOTOPT"; then - { echo "$as_me:$LINENO: result: $OCAMLCDOTOPT" >&5 -echo "${ECHO_T}$OCAMLCDOTOPT" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLCDOTOPT" >&5 +$as_echo "$OCAMLCDOTOPT" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLCDOTOPT" != no ; then - { echo "$as_me:$LINENO: checking ocamlc.opt version" >&5 -echo $ECHO_N "checking ocamlc.opt version... $ECHO_C" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking ocamlc.opt version" >&5 +$as_echo_n "checking ocamlc.opt version... " >&6; } TMPVERSION=`$OCAMLCDOTOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' ` if test "$TMPVERSION" != "$OCAMLVERSION" ; then - { echo "$as_me:$LINENO: result: differs from ocamlc; ocamlc.opt discarded." >&5 -echo "${ECHO_T}differs from ocamlc; ocamlc.opt discarded." >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: differs from ocamlc; ocamlc.opt discarded." >&5 +$as_echo "differs from ocamlc; ocamlc.opt discarded." >&6; } else - { echo "$as_me:$LINENO: result: ok" >&5 -echo "${ECHO_T}ok" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } OCAMLC=$OCAMLCDOTOPT fi fi @@ -1798,10 +1822,10 @@ fi if test "$OCAMLOPT" != no ; then # Extract the first word of "ocamlopt.opt", so it can be a program name with args. set dummy ocamlopt.opt; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLOPTDOTOPT+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLOPTDOTOPT+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPTDOTOPT"; then ac_cv_prog_OCAMLOPTDOTOPT="$OCAMLOPTDOTOPT" # Let the user override the test. @@ -1811,14 +1835,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLOPTDOTOPT="ocamlopt.opt" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLOPTDOTOPT" && ac_cv_prog_OCAMLOPTDOTOPT="no" @@ -1826,24 +1850,24 @@ fi fi OCAMLOPTDOTOPT=$ac_cv_prog_OCAMLOPTDOTOPT if test -n "$OCAMLOPTDOTOPT"; then - { echo "$as_me:$LINENO: result: $OCAMLOPTDOTOPT" >&5 -echo "${ECHO_T}$OCAMLOPTDOTOPT" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLOPTDOTOPT" >&5 +$as_echo "$OCAMLOPTDOTOPT" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLOPTDOTOPT" != no ; then - { echo "$as_me:$LINENO: checking ocamlc.opt version" >&5 -echo $ECHO_N "checking ocamlc.opt version... $ECHO_C" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking ocamlc.opt version" >&5 +$as_echo_n "checking ocamlc.opt version... " >&6; } TMPVER=`$OCAMLOPTDOTOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' ` if test "$TMPVER" != "$OCAMLVERSION" ; then - { echo "$as_me:$LINENO: result: differs from ocamlc; ocamlopt.opt discarded." >&5 -echo "${ECHO_T}differs from ocamlc; ocamlopt.opt discarded." >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: differs from ocamlc; ocamlopt.opt discarded." >&5 +$as_echo "differs from ocamlc; ocamlopt.opt discarded." >&6; } else - { echo "$as_me:$LINENO: result: ok" >&5 -echo "${ECHO_T}ok" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } OCAMLOPT=$OCAMLOPTDOTOPT fi fi @@ -1852,10 +1876,10 @@ fi # ocamldep and ocamlfind should also be present in the path # Extract the first word of "ocamldep", so it can be a program name with args. set dummy ocamldep; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLDEP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLDEP+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDEP"; then ac_cv_prog_OCAMLDEP="$OCAMLDEP" # Let the user override the test. @@ -1865,14 +1889,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLDEP="ocamldep" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLDEP" && ac_cv_prog_OCAMLDEP="no" @@ -1880,26 +1904,24 @@ fi fi OCAMLDEP=$ac_cv_prog_OCAMLDEP if test -n "$OCAMLDEP"; then - { echo "$as_me:$LINENO: result: $OCAMLDEP" >&5 -echo "${ECHO_T}$OCAMLDEP" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLDEP" >&5 +$as_echo "$OCAMLDEP" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLDEP" = no ; then - { { echo "$as_me:$LINENO: error: Cannot find ocamldep." >&5 -echo "$as_me: error: Cannot find ocamldep." >&2;} - { (exit 1); exit 1; }; } + as_fn_error "Cannot find ocamldep." "$LINENO" 5 fi # Extract the first word of "ocamlfind", so it can be a program name with args. set dummy ocamlfind; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLFIND+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLFIND+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLFIND"; then ac_cv_prog_OCAMLFIND="$OCAMLFIND" # Let the user override the test. @@ -1909,14 +1931,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLFIND="ocamlfind" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLFIND" && ac_cv_prog_OCAMLFIND="no" @@ -1924,28 +1946,26 @@ fi fi OCAMLFIND=$ac_cv_prog_OCAMLFIND if test -n "$OCAMLFIND"; then - { echo "$as_me:$LINENO: result: $OCAMLFIND" >&5 -echo "${ECHO_T}$OCAMLFIND" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLFIND" >&5 +$as_echo "$OCAMLFIND" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLFIND" = no ; then - { { echo "$as_me:$LINENO: error: Cannot find ocamlfind." >&5 -echo "$as_me: error: Cannot find ocamlfind." >&2;} - { (exit 1); exit 1; }; } + as_fn_error "Cannot find ocamlfind." "$LINENO" 5 fi # Not mandatory tools # Extract the first word of "ocamldoc", so it can be a program name with args. set dummy ocamldoc; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLDOC+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLDOC+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDOC"; then ac_cv_prog_OCAMLDOC="$OCAMLDOC" # Let the user override the test. @@ -1955,14 +1975,14 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLDOC="ocamldoc" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS test -z "$ac_cv_prog_OCAMLDOC" && ac_cv_prog_OCAMLDOC="true" @@ -1970,17 +1990,17 @@ fi fi OCAMLDOC=$ac_cv_prog_OCAMLDOC if test -n "$OCAMLDOC"; then - { echo "$as_me:$LINENO: result: $OCAMLDOC" >&5 -echo "${ECHO_T}$OCAMLDOC" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLDOC" >&5 +$as_echo "$OCAMLDOC" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi if test "$OCAMLDOC" = true ; then - { echo "$as_me:$LINENO: WARNING: Cannot find ocamldoc" >&5 -echo "$as_me: WARNING: Cannot find ocamldoc" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Cannot find ocamldoc" >&5 +$as_echo "$as_me: WARNING: Cannot find ocamldoc" >&2;} # JS: documentation generator does not work with ocamldoc.opt :( #else # AC_CHECK_PROG(OCAMLDOCOPT,ocamldoc.opt,ocamldoc.opt,no) @@ -1991,10 +2011,10 @@ fi # Extract the first word of "ocamlweb", so it can be a program name with args. set dummy ocamlweb; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLWEB+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLWEB+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLWEB"; then ac_cv_prog_OCAMLWEB="$OCAMLWEB" # Let the user override the test. @@ -2004,35 +2024,35 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLWEB="ocamlweb" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS - test -z "$ac_cv_prog_OCAMLWEB" && ac_cv_prog_OCAMLWEB="true" + test -z "$ac_cv_prog_OCAMLWEB" && ac_cv_prog_OCAMLWEB="ocamlweb" fi fi OCAMLWEB=$ac_cv_prog_OCAMLWEB if test -n "$OCAMLWEB"; then - { echo "$as_me:$LINENO: result: $OCAMLWEB" >&5 -echo "${ECHO_T}$OCAMLWEB" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLWEB" >&5 +$as_echo "$OCAMLWEB" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi # Extract the first word of "ocamlwc", so it can be a program name with args. set dummy ocamlwc; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLWC+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLWC+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLWC"; then ac_cv_prog_OCAMLWC="$OCAMLWC" # Let the user override the test. @@ -2042,35 +2062,35 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLWC="ocamlwc" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS - test -z "$ac_cv_prog_OCAMLWC" && ac_cv_prog_OCAMLWC="true" + test -z "$ac_cv_prog_OCAMLWC" && ac_cv_prog_OCAMLWC="ocamlwc" fi fi OCAMLWC=$ac_cv_prog_OCAMLWC if test -n "$OCAMLWC"; then - { echo "$as_me:$LINENO: result: $OCAMLWC" >&5 -echo "${ECHO_T}$OCAMLWC" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLWC" >&5 +$as_echo "$OCAMLWC" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi # Extract the first word of "ocamldot", so it can be a program name with args. set dummy ocamldot; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_OCAMLDOT+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OCAMLDOT+set}" = set; then : + $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDOT"; then ac_cv_prog_OCAMLDOT="$OCAMLDOT" # Let the user override the test. @@ -2080,38 +2100,38 @@ for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do + for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_OCAMLDOT="ocamldot" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done -done + done IFS=$as_save_IFS - test -z "$ac_cv_prog_OCAMLDOT" && ac_cv_prog_OCAMLDOT="true" + test -z "$ac_cv_prog_OCAMLDOT" && ac_cv_prog_OCAMLDOT="ocamldot" fi fi OCAMLDOT=$ac_cv_prog_OCAMLDOT if test -n "$OCAMLDOT"; then - { echo "$as_me:$LINENO: result: $OCAMLDOT" >&5 -echo "${ECHO_T}$OCAMLDOT" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLDOT" >&5 +$as_echo "$OCAMLDOT" >&6; } else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } fi # platform -{ echo "$as_me:$LINENO: checking platform" >&5 -echo $ECHO_N "checking platform... $ECHO_C" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking platform" >&5 +$as_echo_n "checking platform... " >&6; } #if echo "let _ = Sys.os_type" | ocaml | grep -q Win32; then if test -z "$system" ; then system=`ocamlc -config 2>/dev/null|grep system|sed 's/system: //'` - { echo "$as_me:$LINENO: result: ${system}" >&5 -echo "${ECHO_T}${system}" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${system}" >&5 +$as_echo "${system}" >&6; } # This may be # - mingw # - win32 @@ -2133,17 +2153,60 @@ if test ${use_cygpath} -gt 0 ; then fi # extension for object and library files -{ echo "$as_me:$LINENO: checking extension for object files" >&5 -echo $ECHO_N "checking extension for object files... $ECHO_C" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking extension for object files" >&5 +$as_echo_n "checking extension for object files... " >&6; } OBJEXT=`ocamlc -config 2>/dev/null|grep ext_obj|sed 's/ext_obj: //'` -{ echo "$as_me:$LINENO: result: ${OBJEXT}" >&5 -echo "${ECHO_T}${OBJEXT}" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${OBJEXT}" >&5 +$as_echo "${OBJEXT}" >&6; } -{ echo "$as_me:$LINENO: checking extension for library files" >&5 -echo $ECHO_N "checking extension for library files... $ECHO_C" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking extension for library files" >&5 +$as_echo_n "checking extension for library files... " >&6; } LIBEXT=`ocamlc -config 2>/dev/null|grep ext_lib|sed 's/ext_lib: //'` -{ echo "$as_me:$LINENO: result: ${LIBEXT}" >&5 -echo "${ECHO_T}${LIBEXT}" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${LIBEXT}" >&5 +$as_echo "${LIBEXT}" >&6; } + +# Checking workable native dynlink +HAS_NATDYNLINK=no +as_ac_File=`$as_echo "ac_cv_file_${OCAMLLIB}/dynlink.cmxa" | $as_tr_sh` +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${OCAMLLIB}/dynlink.cmxa" >&5 +$as_echo_n "checking for ${OCAMLLIB}/dynlink.cmxa... " >&6; } +if { as_var=$as_ac_File; eval "test \"\${$as_var+set}\" = set"; }; then : + $as_echo_n "(cached) " >&6 +else + test "$cross_compiling" = yes && + as_fn_error "cannot check for file existence when cross compiling" "$LINENO" 5 +if test -r "${OCAMLLIB}/dynlink.cmxa"; then + eval "$as_ac_File=yes" +else + eval "$as_ac_File=no" +fi +fi +eval ac_res=\$$as_ac_File + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +eval as_val=\$$as_ac_File + if test "x$as_val" = x""yes; then : + HAS_NATDYNLINK=yes +else + HAS_NATDYNLINK=no +fi + + +if test "$HAS_NATDYNLINK" != "no" ; then + echo "let f x y = Dynlink.loadfile \"foo\"; ignore (Dynlink.is_native); abs_float (x -. y)" > test_dynlink.ml + if ($OCAMLOPT -shared -linkall -o test_dynlink.cmxs test_dynlink.ml) \ + 2> /dev/null ; \ + then + HAS_NATDYNLINK=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: native dynlink works fine. Great." >&5 +$as_echo "native dynlink works fine. Great." >&6; } + else + HAS_NATDYNLINK=no + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: native dynlink does not work on your platform. Disabled." >&5 +$as_echo "$as_me: WARNING: native dynlink does not work on your platform. Disabled." >&2;} + fi + rm -f test_dynlink.* +fi # substitutions to perform @@ -2160,6 +2223,7 @@ echo "${ECHO_T}${LIBEXT}" >&6; } + # Finally create the Makefile from Makefile.in ac_config_files="$ac_config_files Makefile" @@ -2190,12 +2254,13 @@ _ACEOF case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done @@ -2203,8 +2268,8 @@ echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) - # `set' does not quote correctly, so add quotes (double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \). + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" @@ -2227,12 +2292,12 @@ echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then test "x$cache_file" != "x/dev/null" && - { echo "$as_me:$LINENO: updating cache $cache_file" >&5 -echo "$as_me: updating cache $cache_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} cat confcache >$cache_file else - { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5 -echo "$as_me: not updating unwritable cache $cache_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache @@ -2249,6 +2314,12 @@ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' +:mline +/\\$/{ + N + s,\\\n,, + b mline +} t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g @@ -2278,11 +2349,11 @@ ac_ltlibobjs= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`echo "$ac_i" | sed "$ac_script"` + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. - ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext" - ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo' + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs @@ -2291,11 +2362,13 @@ LTLIBOBJS=$ac_ltlibobjs : ${CONFIG_STATUS=./config.status} +ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 -echo "$as_me: creating $CONFIG_STATUS" >&6;} -cat >$CONFIG_STATUS <<_ACEOF +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. @@ -2305,59 +2378,79 @@ cat >$CONFIG_STATUS <<_ACEOF debug=false ac_cs_recheck=false ac_cs_silent=false -SHELL=\${CONFIG_SHELL-$SHELL} -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; esac - fi - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' else - PATH_SEPARATOR=: + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' fi - rm -f conf$$.sh + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' fi -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } fi @@ -2366,20 +2459,18 @@ fi # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) -as_nl=' -' IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. -case $0 in +case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done IFS=$as_save_IFS ;; @@ -2390,32 +2481,111 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 fi -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error ERROR [LINENO LOG_FD] +# --------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with status $?, using 1 if that was 0. +as_fn_error () +{ + as_status=$?; test $as_status -eq 0 && as_status=1 + if test "$3"; then + as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3 fi -done + $as_echo "$as_me: error: $1" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + -# Required to use basename. if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr @@ -2429,13 +2599,17 @@ else as_basename=false fi +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi -# Name of the executable. as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | +$as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -2450,104 +2624,103 @@ echo X/"$0" | } s/.*/./; q'` -# CDPATH. -$as_unset CDPATH - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in +case `echo -n x` in #((((( -n*) - case `echo 'x\c'` in + case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -p'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -p' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln + fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir" + + +} # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then - as_mkdir_p=: + as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false @@ -2564,12 +2737,12 @@ else as_test_x=' eval sh -c '\'' if test -d "$1"; then - test -d "$1/."; + test -d "$1/."; else - case $1 in - -*)set "./$1";; + case $1 in #( + -*)set "./$1";; esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in + case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' @@ -2584,13 +2757,19 @@ as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 -# Save the log message, to keep $[0] and so on meaningful, and to +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by $as_me, which was -generated by GNU Autoconf 2.61. Invocation command line was +generated by GNU Autoconf 2.64. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -2603,50 +2782,58 @@ on `(hostname || uname -n) 2>/dev/null | sed 1q` _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ -\`$as_me' instantiates files from templates according to the -current configuration. +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. -Usage: $0 [OPTIONS] [FILE]... +Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit - -q, --quiet do not print progress messages + -q, --quiet, --silent + do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions - --file=FILE[:TEMPLATE] - instantiate the configuration file FILE + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE Configuration files: $config_files -Report bugs to <bug-autoconf@gnu.org>." +Report bugs to the package provider." _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_version="\\ config.status -configured by $0, generated by GNU Autoconf 2.61, - with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" +configured by $0, generated by GNU Autoconf 2.64, + with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" -Copyright (C) 2006 Free Software Foundation, Inc. +Copyright (C) 2009 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' +test -n "\$AWK" || AWK=awk _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -# If no file are specified by the user, then we need to provide default -# value. By we need to know if files were specified by the user. +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do @@ -2668,25 +2855,27 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - echo "$ac_cs_version"; exit ;; + $as_echo "$ac_cs_version"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift - CONFIG_FILES="$CONFIG_FILES $ac_optarg" + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) - echo "$ac_cs_usage"; exit ;; + $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. - -*) { echo "$as_me: error: unrecognized option: $1 -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } ;; + -*) as_fn_error "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; - *) ac_config_targets="$ac_config_targets $1" + *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac @@ -2701,30 +2890,32 @@ if $ac_cs_silent; then fi _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then - echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 - CONFIG_SHELL=$SHELL + set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' export CONFIG_SHELL - exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + exec "\$@" fi _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX - echo "$ac_log" + $as_echo "$ac_log" } >&5 _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets @@ -2732,9 +2923,7 @@ do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; - *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 -echo "$as_me: error: invalid argument: $ac_config_target" >&2;} - { (exit 1); exit 1; }; };; + *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done @@ -2759,7 +2948,7 @@ $debug || trap 'exit_status=$? { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status ' 0 - trap '{ (exit 1); exit 1; }' 1 2 13 15 + trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. @@ -2770,121 +2959,140 @@ $debug || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") -} || -{ - echo "$me: cannot create a temporary directory in ." >&2 - { (exit 1); exit 1; } -} +} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5 -# -# Set up the sed scripts for CONFIG_FILES section. -# - -# No need to generate the scripts if there are no CONFIG_FILES. -# This happens for instance when ./config.status config.h +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then -_ACEOF +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$tmp/subs1.awk" && +_ACEOF +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do - cat >conf$$subs.sed <<_ACEOF -SHELL!$SHELL$ac_delim -PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim -PACKAGE_NAME!$PACKAGE_NAME$ac_delim -PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim -PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim -PACKAGE_STRING!$PACKAGE_STRING$ac_delim -PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim -exec_prefix!$exec_prefix$ac_delim -prefix!$prefix$ac_delim -program_transform_name!$program_transform_name$ac_delim -bindir!$bindir$ac_delim -sbindir!$sbindir$ac_delim -libexecdir!$libexecdir$ac_delim -datarootdir!$datarootdir$ac_delim -datadir!$datadir$ac_delim -sysconfdir!$sysconfdir$ac_delim -sharedstatedir!$sharedstatedir$ac_delim -localstatedir!$localstatedir$ac_delim -includedir!$includedir$ac_delim -oldincludedir!$oldincludedir$ac_delim -docdir!$docdir$ac_delim -infodir!$infodir$ac_delim -htmldir!$htmldir$ac_delim -dvidir!$dvidir$ac_delim -pdfdir!$pdfdir$ac_delim -psdir!$psdir$ac_delim -libdir!$libdir$ac_delim -localedir!$localedir$ac_delim -mandir!$mandir$ac_delim -DEFS!$DEFS$ac_delim -ECHO_C!$ECHO_C$ac_delim -ECHO_N!$ECHO_N$ac_delim -ECHO_T!$ECHO_T$ac_delim -LIBS!$LIBS$ac_delim -build_alias!$build_alias$ac_delim -host_alias!$host_alias$ac_delim -target_alias!$target_alias$ac_delim -OCAMLC!$OCAMLC$ac_delim -OCAMLOPT!$OCAMLOPT$ac_delim -OCAMLCDOTOPT!$OCAMLCDOTOPT$ac_delim -OCAMLOPTDOTOPT!$OCAMLOPTDOTOPT$ac_delim -OCAMLDEP!$OCAMLDEP$ac_delim -OCAMLFIND!$OCAMLFIND$ac_delim -OCAMLDOC!$OCAMLDOC$ac_delim -OCAMLWEB!$OCAMLWEB$ac_delim -OCAMLWC!$OCAMLWC$ac_delim -OCAMLDOT!$OCAMLDOT$ac_delim -OCAMLBEST!$OCAMLBEST$ac_delim -OCAMLVERSION!$OCAMLVERSION$ac_delim -OCAMLLIB!$OCAMLLIB$ac_delim -OBJEXT!$OBJEXT$ac_delim -LIBEXT!$LIBEXT$ac_delim -LIBOBJS!$LIBOBJS$ac_delim -LTLIBOBJS!$LTLIBOBJS$ac_delim -_ACEOF + . ./conf$$subs.sh || + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 - if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 54; then + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then - { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done +rm -f conf$$subs.sh -ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed` -if test -n "$ac_eof"; then - ac_eof=`echo "$ac_eof" | sort -nru | sed 1q` - ac_eof=`expr $ac_eof + 1` -fi +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\).*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\).*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' <conf$$subs.awk | sed ' +/^[^""]/{ + N + s/\n// +} +' >>$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} -cat >>$CONFIG_STATUS <<_ACEOF -cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end +_ACAWK _ACEOF -sed ' -s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g -s/^/s,@/; s/!/@,|#_!!_#|/ -:n -t n -s/'"$ac_delim"'$/,g/; t -s/$/\\/; p -N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n -' >>$CONFIG_STATUS <conf$$subs.sed -rm -f conf$$subs.sed -cat >>$CONFIG_STATUS <<_ACEOF -:end -s/|#_!!_#|//g -CEOF$ac_eof +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ + || as_fn_error "could not setup config files machinery" "$LINENO" 5 _ACEOF - # VPATH may cause trouble with some makes, so we remove $(srcdir), # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty @@ -2900,20 +3108,20 @@ s/^[^=]*=[ ]*$// }' fi -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" -for ac_tag in :F $CONFIG_FILES +eval set X " :F $CONFIG_FILES " +shift +for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5 -echo "$as_me: error: Invalid tag $ac_tag." >&2;} - { (exit 1); exit 1; }; };; + :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -2941,26 +3149,34 @@ echo "$as_me: error: Invalid tag $ac_tag." >&2;} [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5 -echo "$as_me: error: cannot find input file: $ac_f" >&2;} - { (exit 1); exit 1; }; };; + as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac - ac_file_inputs="$ac_file_inputs $ac_f" + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ - configure_input="Generated from "`IFS=: - echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure." + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin";; + *:-:* | *:-) cat >"$tmp/stdin" \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac @@ -2970,42 +3186,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -echo X"$ac_file" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - { as_dir="$ac_dir" - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -echo X"$as_dir" | +$as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -3023,20 +3204,15 @@ echo X"$as_dir" | q } s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } + as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -3072,12 +3248,12 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= - -case `sed -n '/datarootdir/ { +ac_sed_dataroot=' +/datarootdir/ { p q } @@ -3085,36 +3261,37 @@ case `sed -n '/datarootdir/ { /@docdir@/p /@infodir@/p /@localedir@/p -/@mandir@/p -' $ac_file_inputs` in +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g - s&\\\${datarootdir}&$datarootdir&g' ;; + s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF - sed "$ac_vpsub +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub $extrasub _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b -s&@configure_input@&$configure_input&;t t +s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t @@ -3123,21 +3300,24 @@ s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack -" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir' + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&5 -echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&2;} rm -f "$tmp/stdin" case $ac_file in - -) cat "$tmp/out"; rm -f "$tmp/out";; - *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;; - esac + -) cat "$tmp/out" && rm -f "$tmp/out";; + *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; + esac \ + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; @@ -3147,11 +3327,13 @@ which seems to be undefined. Please make sure it is defined." >&2;} done # for ac_tag -{ (exit 0); exit 0; } +as_fn_exit 0 _ACEOF -chmod +x $CONFIG_STATUS ac_clean_files=$ac_clean_files_save +test $ac_write_fail = 0 || + as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5 + # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. @@ -3171,7 +3353,11 @@ if test "$no_create" != yes; then exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. - $ac_cs_success || { (exit 1); exit 1; } + $ac_cs_success || as_fn_exit $? +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi chmod a-w Makefile diff --git a/configure.in b/configure.in index bdfdbcc..d585984 100644 --- a/configure.in +++ b/configure.in @@ -24,7 +24,7 @@ # OCAMLC "ocamlc" if present in the path, or a failure # or "ocamlc.opt" if present with same version number as ocamlc # OCAMLOPT "ocamlopt" (or "ocamlopt.opt" if present), or "no" -# OCAMLBEST either "byte" if no native compiler was found, +# OCAMLBEST either "byte" if no native compiler was found, # or "opt" otherwise # OCAMLDEP "ocamldep" # OCAMLLIB the path to the ocaml standard library @@ -35,7 +35,7 @@ # OCAMLWC "ocamlwc" (not mandatory) # OCAMLDOT "ocamldot" (not mandatory) -# check for one particular file of the sources +# check for one particular file of the sources # ADAPT THE FOLLOWING LINE TO YOUR SOURCES! AC_INIT(src/date.ml) @@ -58,7 +58,7 @@ case $OCAMLVERSION in *) echo "${ECHO_T}Unsupported version!"; exit 2;; esac -OCAMLLIB=`$OCAMLC -where` +OCAMLLIB=`$OCAMLC -where | tr -d '\r'` echo "ocaml library path is $OCAMLLIB" # then we look for ocamlopt; if not present, we issue a warning @@ -132,9 +132,9 @@ if test "$OCAMLDOC" = true ; then # fi fi -AC_CHECK_PROG(OCAMLWEB,ocamlweb,ocamlweb,true) -AC_CHECK_PROG(OCAMLWC,ocamlwc,ocamlwc,true) -AC_CHECK_PROG(OCAMLDOT,ocamldot,ocamldot,true) +AC_CHECK_PROG(OCAMLWEB,ocamlweb,ocamlweb,ocamlweb) +AC_CHECK_PROG(OCAMLWC,ocamlwc,ocamlwc,ocamlwc) +AC_CHECK_PROG(OCAMLDOT,ocamldot,ocamldot,ocamldot) # platform AC_MSG_CHECKING(platform) @@ -171,6 +171,24 @@ AC_MSG_CHECKING(extension for library files) LIBEXT=`ocamlc -config 2>/dev/null|grep ext_lib|sed 's/ext_lib: //'` AC_MSG_RESULT(${LIBEXT}) +# Checking workable native dynlink +HAS_NATDYNLINK=no +AC_CHECK_FILE(${OCAMLLIB}/dynlink.cmxa,HAS_NATDYNLINK=yes,HAS_NATDYNLINK=no) + +if test "$HAS_NATDYNLINK" != "no" ; then + echo "let f x y = Dynlink.loadfile \"foo\"; ignore (Dynlink.is_native); abs_float (x -. y)" > test_dynlink.ml + if ($OCAMLOPT -shared -linkall -o test_dynlink.cmxs test_dynlink.ml) \ + 2> /dev/null ; \ + then + HAS_NATDYNLINK=yes + AC_MSG_RESULT([native dynlink works fine. Great.]) + else + HAS_NATDYNLINK=no + AC_MSG_WARN([native dynlink does not work on your platform. Disabled.]) + fi + rm -f test_dynlink.* +fi + # substitutions to perform AC_SUBST(OCAMLC) AC_SUBST(OCAMLOPT) @@ -185,6 +203,7 @@ AC_SUBST(OCAMLWC) AC_SUBST(OCAMLDOT) AC_SUBST(OBJEXT) AC_SUBST(LIBEXT) +AC_SUBST(HAS_NATDYNLINK) # Finally create the Makefile from Makefile.in AC_OUTPUT(Makefile) diff --git a/doc/Calendar.Precise.html b/doc/Calendar.Precise.html index 78798e9..49b17cc 100644 --- a/doc/Calendar.Precise.html +++ b/doc/Calendar.Precise.html @@ -44,17 +44,14 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> -<div class="info"> -Type of a date refined with a time, so called a calendar.<br> -</div> - <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Date.html">Date</a>: <code class="type"><a href="Date_sig.S.html">Date_sig.S</a></code><code class="type"> </code></pre><div class="info"> Date implementation used by this calendar. </div> <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Time.html">Time</a>: <code class="type"><a href="Time_sig.S.html">Time_sig.S</a></code><code class="type"> </code></pre><div class="info"> Time implementation used by this calendar. </div> +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> + <pre><span class="keyword">type</span> <a name="TYPEday"></a><code class="type"></code>day = <code class="type">Date.day</code> = </pre><table class="typetable"> <tr> <td align="left" valign="top" > @@ -218,8 +215,8 @@ The different fields of a calendar.<br> </ul> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. - The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> +Labelled version of <code class="code">make</code>. + The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> and <code class="code">second</code>) is <code class="code">1</code> (resp. <code class="code">0</code>).<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>D.Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -235,8 +232,8 @@ Labelled version of <code class="code">make</code>. zone).<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_jd"></a>from_jd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Return the Julian day. - More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the +Return the Julian day. + More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the time.<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_mjd"></a>from_mjd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> @@ -286,7 +283,7 @@ Those functions have the same behavious as those defined in <b>See also</b> <a href="Date_sig.S.html#VALyear">Date_sig.S.year</a><br> </div> <br> -<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and +<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and <a href="Date_sig.S.html#VALto_mjd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_mjd</code></a>.<br> <pre><span class="keyword">val</span> <a name="VALto_jd"></a>to_jd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><pre><span class="keyword">val</span> <a name="VALto_mjd"></a>to_mjd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><br> Those functions have the same behavious as those defined in @@ -347,15 +344,15 @@ Convert a calendar into the <code class="code">unix.tm</code> type. <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_unixtm"></a>from_unixtm : <code class="type">Unix.tm -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. +Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. So, The following invariant holds: <code class="code">hour (from_unixtm u) = u.<span class="constructor">Unix</span>.tm_hour</code>.<br> <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. - So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. + So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. More precise than <a href="Date_sig.S.html#VALto_unixfloat"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_unixfloat</code></a>.<br> <b>Since</b> 1.01<br> </div> @@ -366,7 +363,7 @@ Inverse of <code class="code">to_unixfloat</code>. Assumes the current time zone <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Convert a date to a calendar. +Convert a date to a calendar. The time is midnight in the current time zone.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Date.t</code></pre><div class="info"> @@ -388,13 +385,17 @@ A period is the number of seconds between two calendars. <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALadd">Date_sig.S.add</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> <a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALsub">Date_sig.S.sub</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">Period.t</a></code></pre><div class="info"> +<b>Since</b> 2.03<br> +<b>See also</b> <a href="Date_sig.S.html#VALprecise_sub">Date_sig.S.precise_sub</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALrem">Date_sig.S.rem</a><br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEfield">field</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Calendar.html b/doc/Calendar.html index 818df97..0b7edd7 100644 --- a/doc/Calendar.html +++ b/doc/Calendar.html @@ -38,7 +38,7 @@ <p> This module uses float. Then results may be unprecise, especially - comparison of calendars which differ with few seconds. + comparison of calendars which differ with few seconds. In this case, consider to use module <code class="code"><span class="constructor">Precise</span></code>.<br> <hr width="100%"> <pre><span class="keyword">include</span> <a href="Calendar_sig.S.html">Calendar_sig.S</a></pre> diff --git a/doc/Calendar_builder.Make.html b/doc/Calendar_builder.Make.html index fdb0600..cf36745 100644 --- a/doc/Calendar_builder.Make.html +++ b/doc/Calendar_builder.Make.html @@ -68,17 +68,14 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> -<div class="info"> -Type of a date refined with a time, so called a calendar.<br> -</div> - <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Date.html">Date</a>: <code class="type"><a href="Date_sig.S.html">Date_sig.S</a></code><code class="type"> </code></pre><div class="info"> Date implementation used by this calendar. </div> <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Time.html">Time</a>: <code class="type"><a href="Time_sig.S.html">Time_sig.S</a></code><code class="type"> </code></pre><div class="info"> Time implementation used by this calendar. </div> +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> + <pre><span class="keyword">type</span> <a name="TYPEday"></a><code class="type"></code>day = <code class="type">Date.day</code> = </pre><table class="typetable"> <tr> <td align="left" valign="top" > @@ -242,8 +239,8 @@ The different fields of a calendar.<br> </ul> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. - The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> +Labelled version of <code class="code">make</code>. + The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> and <code class="code">second</code>) is <code class="code">1</code> (resp. <code class="code">0</code>).<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>D.Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -259,8 +256,8 @@ Labelled version of <code class="code">make</code>. zone).<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_jd"></a>from_jd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Return the Julian day. - More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the +Return the Julian day. + More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the time.<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_mjd"></a>from_mjd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> @@ -310,7 +307,7 @@ Those functions have the same behavious as those defined in <b>See also</b> <a href="Date_sig.S.html#VALyear">Date_sig.S.year</a><br> </div> <br> -<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and +<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and <a href="Date_sig.S.html#VALto_mjd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_mjd</code></a>.<br> <pre><span class="keyword">val</span> <a name="VALto_jd"></a>to_jd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><pre><span class="keyword">val</span> <a name="VALto_mjd"></a>to_mjd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><br> Those functions have the same behavious as those defined in @@ -371,15 +368,15 @@ Convert a calendar into the <code class="code">unix.tm</code> type. <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_unixtm"></a>from_unixtm : <code class="type">Unix.tm -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. +Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. So, The following invariant holds: <code class="code">hour (from_unixtm u) = u.<span class="constructor">Unix</span>.tm_hour</code>.<br> <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. - So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. + So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. More precise than <a href="Date_sig.S.html#VALto_unixfloat"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_unixfloat</code></a>.<br> <b>Since</b> 1.01<br> </div> @@ -390,7 +387,7 @@ Inverse of <code class="code">to_unixfloat</code>. Assumes the current time zone <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Convert a date to a calendar. +Convert a date to a calendar. The time is midnight in the current time zone.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Date.t</code></pre><div class="info"> @@ -412,13 +409,17 @@ A period is the number of seconds between two calendars. <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALadd">Date_sig.S.add</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> <a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALsub">Date_sig.S.sub</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">Period.t</a></code></pre><div class="info"> +<b>Since</b> 2.03<br> +<b>See also</b> <a href="Date_sig.S.html#VALprecise_sub">Date_sig.S.precise_sub</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALrem">Date_sig.S.rem</a><br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEfield">field</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Calendar_builder.Make_Precise.html b/doc/Calendar_builder.Make_Precise.html index d693ed1..6f7844f 100644 --- a/doc/Calendar_builder.Make_Precise.html +++ b/doc/Calendar_builder.Make_Precise.html @@ -66,17 +66,14 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> -<div class="info"> -Type of a date refined with a time, so called a calendar.<br> -</div> - <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Date.html">Date</a>: <code class="type"><a href="Date_sig.S.html">Date_sig.S</a></code><code class="type"> </code></pre><div class="info"> Date implementation used by this calendar. </div> <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Time.html">Time</a>: <code class="type"><a href="Time_sig.S.html">Time_sig.S</a></code><code class="type"> </code></pre><div class="info"> Time implementation used by this calendar. </div> +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> + <pre><span class="keyword">type</span> <a name="TYPEday"></a><code class="type"></code>day = <code class="type">Date.day</code> = </pre><table class="typetable"> <tr> <td align="left" valign="top" > @@ -240,8 +237,8 @@ The different fields of a calendar.<br> </ul> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. - The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> +Labelled version of <code class="code">make</code>. + The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> and <code class="code">second</code>) is <code class="code">1</code> (resp. <code class="code">0</code>).<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>D.Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -257,8 +254,8 @@ Labelled version of <code class="code">make</code>. zone).<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_jd"></a>from_jd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Return the Julian day. - More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the +Return the Julian day. + More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the time.<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_mjd"></a>from_mjd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> @@ -308,7 +305,7 @@ Those functions have the same behavious as those defined in <b>See also</b> <a href="Date_sig.S.html#VALyear">Date_sig.S.year</a><br> </div> <br> -<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and +<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and <a href="Date_sig.S.html#VALto_mjd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_mjd</code></a>.<br> <pre><span class="keyword">val</span> <a name="VALto_jd"></a>to_jd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><pre><span class="keyword">val</span> <a name="VALto_mjd"></a>to_mjd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><br> Those functions have the same behavious as those defined in @@ -369,15 +366,15 @@ Convert a calendar into the <code class="code">unix.tm</code> type. <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_unixtm"></a>from_unixtm : <code class="type">Unix.tm -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. +Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. So, The following invariant holds: <code class="code">hour (from_unixtm u) = u.<span class="constructor">Unix</span>.tm_hour</code>.<br> <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. - So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. + So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. More precise than <a href="Date_sig.S.html#VALto_unixfloat"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_unixfloat</code></a>.<br> <b>Since</b> 1.01<br> </div> @@ -388,7 +385,7 @@ Inverse of <code class="code">to_unixfloat</code>. Assumes the current time zone <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Convert a date to a calendar. +Convert a date to a calendar. The time is midnight in the current time zone.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Date.t</code></pre><div class="info"> @@ -410,13 +407,17 @@ A period is the number of seconds between two calendars. <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALadd">Date_sig.S.add</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> <a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALsub">Date_sig.S.sub</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">Period.t</a></code></pre><div class="info"> +<b>Since</b> 2.03<br> +<b>See also</b> <a href="Date_sig.S.html#VALprecise_sub">Date_sig.S.precise_sub</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALrem">Date_sig.S.rem</a><br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEfield">field</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Calendar_sig.S.Date.html b/doc/Calendar_sig.S.Date.html index 264bae0..deda6e3 100644 --- a/doc/Calendar_sig.S.Date.html +++ b/doc/Calendar_sig.S.Date.html @@ -48,7 +48,19 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> +<pre><span class="keyword">type</span> <a name="TYPEfield"></a><code class="type"></code>field = <code class="type"><a href="Period.html#TYPEdate_field">Period.date_field</a></code> </pre> +<div class="info"> +The different fields of a date.<br> +<b>Since</b> 2.02<br> +</div> + +<pre><span class="keyword">type</span> <a name="TYPEdate"></a><code class="type">-[< <a href="Date_sig.S.html#TYPEfield">field</a> ]</code> date </pre> +<div class="info"> +Type of a date, without specifying any precision level.<br> +<b>Since</b> 2.02<br> +</div> + +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t = <code class="type"><a href="Date_sig.S.html#TYPEfield">field</a> <a href="Date_sig.S.html#TYPEdate">date</a></code> </pre> <div class="info"> Type of a date.<br> </div> @@ -203,11 +215,6 @@ Months of the year.<br> Year as an <code class="code">int</code>.<br> </div> -<pre><span class="keyword">type</span> <a name="TYPEfield"></a><code class="type"></code>field = <code class="type">[ `Day | `Month | `Week | `Year ]</code> </pre> -<div class="info"> -The different fields of a date.<br> -</div> - <br> <a name="2_Exceptions"></a> <h2>Exceptions</h2><br> @@ -217,7 +224,7 @@ Raised when a date is outside the Julian period.<br> </div> <pre><span class="keyword">exception</span> <a name="EXCEPTIONUndefined"></a>Undefined</pre> <div class="info"> -Raised when a date belongs to +Raised when a date belongs to <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code>.<br> </div> <br> @@ -234,7 +241,7 @@ Raised when a date belongs to (-4) and 0.<br> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:<a href="Date_sig.S.html#TYPEyear">year</a> -> ?month:int -> ?day:int -> unit -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. +Labelled version of <code class="code">make</code>. The default value of <code class="code">month</code> and <code class="code">day</code> is <code class="code">1</code>.<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -242,6 +249,16 @@ Labelled version of <code class="code">make</code>. 14th, 1582]</code>.</li> </ul> </div> +<pre><span class="keyword">val</span> <a name="VALmake_year"></a>make_year : <code class="type">int -> [< `Year ] <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">make_year y</code> makes a date only represented by its year <code class="code">y</code>. The month + and the day of such a date are not relevant.<br> +<b>Since</b> 2.02<br> +</div> +<pre><span class="keyword">val</span> <a name="VALmake_year_month"></a>make_year_month : <code class="type">int -> int -> [< `Month | `Year ] <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">make_year_month y m</code> makes a date only represented by its year <code class="code">y</code> and + its month <code class="code">m</code>. The day of such a date is not relevant.<br> +<b>Since</b> 2.02<br> +</div> <pre><span class="keyword">val</span> <a name="VALtoday"></a>today : <code class="type">unit -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> Date of the current day (based on <code class="code"><span class="constructor">Time_Zone</span>.current ()</code>).<br> </div> @@ -262,7 +279,7 @@ Make a date from a year and its day of the year.<br> <br> <a name="2_Getters"></a> <h2>Getters</h2><br> -<pre><span class="keyword">val</span> <a name="VALdays_in_month"></a>days_in_month : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALdays_in_month"></a>days_in_month : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Month `Year ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Number of days in the month of a date.<br> <b>Example:</b> <code class="code">days_in_month (make 2003 6 26)</code> returns <code class="code">30</code>.<br> </div> @@ -286,11 +303,11 @@ Week.<br> </li><li><code class="code">week (make 2000 1 2)</code> returns <code class="code">52</code>.<br> </li><li><code class="code">week (make 2000 1 3)</code> returns <code class="code">1</code>.<br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEmonth">month</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Month ] <a href="Date_sig.S.html#TYPEdate">date</a> -> <a href="Date_sig.S.html#TYPEmonth">month</a></code></pre><div class="info"> Month.<br> <b>Example:</b> <code class="code">month (make 2003 6 26)</code> returns <code class="code"><span class="constructor">Jun</span></code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEyear">year</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Year ] <a href="Date_sig.S.html#TYPEdate">date</a> -> <a href="Date_sig.S.html#TYPEyear">year</a></code></pre><div class="info"> Year.<br> <b>Example:</b> <code class="code">year (make 2003 6 26)</code> returns <code class="code">2003</code>.<br> </div> @@ -306,16 +323,16 @@ Modified Julian day (i.e. Julian day - 2 400 001). <br> <a name="2_Datesarecomparable"></a> <h2>Dates are comparable</h2><br> -<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> bool</code></pre><div class="info"> Equality function between two dates.<br> <b>Since</b> 1.09.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALequal">Utils.Comparable.equal</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Comparison function between two dates.<br> <b>See also</b> <a href="Utils.Comparable.html#VALcompare">Utils.Comparable.compare</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Hash function for dates.<br> <b>Since</b> 2.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALhash">Utils.Comparable.hash</a><br> @@ -346,8 +363,8 @@ Return <code class="code"><span class="keyword">true</span></code> iff a date be <a name="2_Coercions"></a> <h2>Coercions</h2><br> <pre><span class="keyword">val</span> <a name="VALto_unixtm"></a>to_unixtm : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Unix.tm</code></pre><div class="info"> -Convert a date into the <code class="code"><span class="constructor">Unix</span>.tm</code> type. - The field <code class="code">is_isdst</code> is always <code class="code"><span class="keyword">false</span></code>. The fields <code class="code"><span class="constructor">Unix</span>.tm_sec</code>, +Convert a date into the <code class="code"><span class="constructor">Unix</span>.tm</code> type. + The field <code class="code">is_isdst</code> is always <code class="code"><span class="keyword">false</span></code>. The fields <code class="code"><span class="constructor">Unix</span>.tm_sec</code>, <code class="code"><span class="constructor">Unix</span>.tm_min</code> and <code class="code"><span class="constructor">Unix</span>.tm_hour</code> are irrelevant.<br> <b>Since</b> 1.01<br> </div> @@ -356,8 +373,8 @@ Inverse of <code class="code">to_unixtm</code>. Assume the current time zone.<br <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> - returns <code class="code">0.0</code>. So such a float is convertible with those of the <code class="code"><span class="constructor">Unix</span></code> +Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> + returns <code class="code">0.0</code>. So such a float is convertible with those of the <code class="code"><span class="constructor">Unix</span></code> module. The fractional part of the result is always <code class="code">0</code>.<br> <b>Since</b> 1.01<br> </div> @@ -408,22 +425,32 @@ A period is the number of days between two dates. <br> <a name="2_Arithmeticoperationsondatesandperiods"></a> <h2>Arithmetic operations on dates and periods</h2><br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a Period.period -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">add d p</code> returns <code class="code">d + p</code>.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> <li><code>Undefined</code> when the resulting date belongs to <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code>.</li> </ul> -<b>Examples:</b><ul><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 2)</code> returns the date +<b>Examples:</b><ul><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 2)</code> returns the date 2004-3-2 (following the coercion rule describes in the introduction).<br> -</li><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 1)</code> returns the date +</li><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 1)</code> returns the date 2004-1-31<br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> > `Day `Week ] Period.period</code></pre><div class="info"> <code class="code">sub d1 d2</code> returns the period between <code class="code">d1</code> and <code class="code">d2</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a <a href="Date_sig.S.html#TYPEdate">date</a> -> Period.t</code></pre><div class="info"> +<code class="code">precise_sub d1 d2</code> returns the period between <code class="code">d1</code> and <code class="code">d2</code>. + It is equivalent to <code class="code">sub</code>, but:<ul> +<li>the period is expressed with a number of years, months and days, not + only with a number of days;</li> +<li>it is less efficient.</li> +</ul> +<br> +<b>Since</b> 2.03<br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a Period.period -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">rem d p</code> is equivalent to <code class="code">add d (<span class="constructor">Period</span>.opp p)</code>.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -431,7 +458,7 @@ A period is the number of days between two dates. 1582; <span class="constructor">October</span> 14th, 1582]</code>.</li> </ul> </div> -<pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEfield">field</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -> 'a -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">next d f</code> returns the date corresponding to the next specified field.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -441,8 +468,8 @@ A period is the number of days between two dates. <b>Example:</b> <code class="code">next (make 2003 12 31) <span class="keywordsign">`</span><span class="constructor">Month</span></code> returns the date 2004-1-31 (i.e. one month later).<br> </div> -<pre><span class="keyword">val</span> <a name="VALprev"></a>prev : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEfield">field</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -<code class="code">prev d f</code> returns the date corresponding to the previous specified +<pre><span class="keyword">val</span> <a name="VALprev"></a>prev : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -> 'a -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">prev d f</code> returns the date corresponding to the previous specified field.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -463,7 +490,7 @@ Return <code class="code"><span class="keyword">true</span></code> if two years otherwise.<br> </div> <pre><span class="keyword">val</span> <a name="VALdays_in_year"></a>days_in_year : <code class="type">?month:<a href="Date_sig.S.html#TYPEmonth">month</a> -> <a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Number of days in a year. +Number of days in a year. <p> <code class="code">days_in_year ~month y</code> returns the number of days in the year <code class="code">y</code> up @@ -493,42 +520,42 @@ Millenium of a year.<br> </li><li><code class="code">millenium 2000</code> returns 2<br> </li></ul></div> <pre><span class="keyword">val</span> <a name="VALsolar_number"></a>solar_number : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Solar number. +Solar number. <p> In the Julian calendar there is a one-to-one relationship between the Solar number and the day on which a particular date falls.<br> </div> <pre><span class="keyword">val</span> <a name="VALindiction"></a>indiction : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Indiction. +Indiction. <p> - The Indiction was used in the middle ages to specify the position of a + The Indiction was used in the middle ages to specify the position of a year in a 15 year taxation cycle. It was introduced by emperor Constantine the Great on 1 September 312 and ceased to be used in - 1806. + 1806. <p> The Indiction has no astronomical significance.<br> </div> <pre><span class="keyword">val</span> <a name="VALgolden_number"></a>golden_number : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Golden number. +Golden number. <p> Considering that the relationship between the moon's phases and the days of the year repeats itself every 19 years, it is natural to - associate a number between 1 and 19 with each year. + associate a number between 1 and 19 with each year. This number is the so-called Golden number.<br> </div> <pre><span class="keyword">val</span> <a name="VALepact"></a>epact : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Epact. +Epact. <p> - The Epact is a measure of the age of the moon (i.e. the number of days + The Epact is a measure of the age of the moon (i.e. the number of days that have passed since an "official" new moon) on a particular date.<br> </div> <pre><span class="keyword">val</span> <a name="VALeaster"></a>easter : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Easter Sunday. +Easter Sunday. <p> In the Christian world, Easter (and the days immediately preceding it) diff --git a/doc/Calendar_sig.S.Period.html b/doc/Calendar_sig.S.Period.html index b02e30e..962c3e0 100644 --- a/doc/Calendar_sig.S.Period.html +++ b/doc/Calendar_sig.S.Period.html @@ -25,6 +25,8 @@ <link title="Fcalendar" rel="Chapter" href="Fcalendar.html"> <link title="Printer" rel="Chapter" href="Printer.html"> <link title="Version" rel="Chapter" href="Version.html"><link title="Arithmetic operations" rel="Section" href="#3_Arithmeticoperations"> +<link title="Period is an additive monoid" rel="Section" href="#3_Periodisanadditivemonoid"> +<link title="Periods are comparable" rel="Section" href="#3_Periodsarecomparable"> <link title="Constructors" rel="Section" href="#3_Constructors"> <link title="Coercions" rel="Section" href="#3_Coercions"> <title>Calendar_sig.S.Period</title> @@ -40,56 +42,94 @@ <br> <a name="3_Arithmeticoperations"></a> <h3>Arithmetic operations</h3><br> -<pre><span class="keyword">include</span> <a href="Period.S.html">Period.S</a></pre> +<pre><span class="keyword">type</span> <a name="TYPEperiod"></a><code class="type">+[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ]</code> period </pre> + +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t = <code class="type"><a href="Period.html#TYPEdate_field">Period.date_field</a> <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code> </pre> +<div class="info"> +Type of a period.<br> +</div> + +<br> +<a name="3_Periodisanadditivemonoid"></a> +<h3>Period is an additive monoid</h3><br> +<pre><span class="keyword">val</span> <a name="VALempty"></a>empty : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> +The empty period.<br> +</div> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> +Addition of periods.<br> +</div> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> +Substraction of periods.<br> +</div> +<pre><span class="keyword">val</span> <a name="VALopp"></a>opp : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> +Opposite of a period.<br> +</div> +<br> +<a name="3_Periodsarecomparable"></a> +<h3>Periods are comparable</h3><br> +<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> bool</code></pre><div class="info"> +Equality function between two periods.<br> +<b>Since</b> 1.09.0<br> +<b>See also</b> <a href="Utils.Comparable.html#VALequal">Utils.Comparable.equal</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> int</code></pre><div class="info"> +Comparison function between two periods.<br> +<b>See also</b> <a href="Utils.Comparable.html#VALcompare">Utils.Comparable.compare</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> int</code></pre><div class="info"> +Hash function for periods.<br> +<b>Since</b> 2.0<br> +<b>See also</b> <a href="Utils.Comparable.html#VALhash">Utils.Comparable.hash</a><br> +</div> <br> <a name="3_Constructors"></a> <h3>Constructors</h3><br> -<pre><span class="keyword">val</span> <a name="VALmake"></a>make : <code class="type">int -> int -> int -> int -> int -> <a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> -<code class="code">make year month day hour minute second</code> makes a period of the +<pre><span class="keyword">val</span> <a name="VALmake"></a>make : <code class="type">int -><br> int -> int -> int -> int -> <a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">t</a></code></pre><div class="info"> +<code class="code">make year month day hour minute second</code> makes a period of the specified length.<br> </div> -<pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">?year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. +<pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">?year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -><br> ?second:<a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -> unit -> <a href="Calendar_sig.S.Period.html#TYPEt">t</a></code></pre><div class="info"> +Labelled version of <code class="code">make</code>. The default value of each argument is <code class="code">0</code>.<br> </div> <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.Period.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Year ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.Period.html#VALyear">Date_sig.S.Period.year</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Month `Year ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.Period.html#VALmonth">Date_sig.S.Period.month</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALweek"></a>week : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALweek"></a>week : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.Period.html#VALweek">Date_sig.S.Period.week</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALday"></a>day : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALday"></a>day : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.Period.html#VALday">Date_sig.S.Period.day</a><br> </div> <br> Those functions have the same behavious as those defined in .<br> -<pre><span class="keyword">val</span> <a name="VALhour"></a>hour : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALhour"></a>hour : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Time_sig.S.Period.html#VALhour">Time_sig.S.Period.hour</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALminute"></a>minute : <code class="type">int -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALminute"></a>minute : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Time_sig.S.Period.html#VALminute">Time_sig.S.Period.minute</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsecond"></a>second : <code class="type"><a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsecond"></a>second : <code class="type"><a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> <b>See also</b> <a href="Time_sig.S.Period.html#VALsecond">Time_sig.S.Period.second</a><br> </div> <br> <a name="3_Coercions"></a> <h3>Coercions</h3><br> -<pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.Period.t -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) Date.Period.period -><br> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> Convert a date period to a calendar period.<br> </div> -<pre><span class="keyword">val</span> <a name="VALfrom_time"></a>from_time : <code class="type">Time.Period.t -> <a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALfrom_time"></a>from_time : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) Time.Period.period -><br> 'a <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a></code></pre><div class="info"> Convert a time period to a calendar period.<br> </div> -<pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a> -> Date.Period.t</code></pre><div class="info"> -Convert a calendar period to a date period. +<pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type">([< Date.field ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -> 'a Date.Period.period</code></pre><div class="info"> +Convert a calendar period to a date period. The fractional time period is ignored.<br> <b>Example:</b> <code class="code">to_date (hour 60)</code> is equivalent to <code class="code"><span class="constructor">Date</span>.<span class="constructor">Period</span>.days 2</code>.<br> </div> @@ -98,7 +138,8 @@ Convert a calendar period to a date period. <code class="code">= <span class="constructor">Date</span>.<span class="constructor">Period</span>.<span class="constructor">Not_computable</span></code>.<br> <b>Since</b> 1.04<br> </div> -<pre><span class="keyword">val</span> <a name="VALto_time"></a>to_time : <code class="type"><a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a> -> Time.Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALto_time"></a>to_time : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> 'a Time.Period.period</code></pre><div class="info"> +<span class="warning">Deprecated.</span>since 2.02: use <a href="Calendar_sig.S.Period.html#VALsafe_to_time"><code class="code"><span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.safe_to_time</code></a> instead<br> Convert a calendar period to a date period.<br> <b>Since</b> 1.04<br> <b>Raises</b> <code>Not_computable</code> if the time period is not computable.<br> @@ -108,7 +149,11 @@ Convert a calendar period to a date period.<br> </li><li><code class="code">to_time (day 6)</code> returns a time period of <code class="code">24 * 3600 * 6 = 518400</code> seconds<br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALymds"></a>ymds : <code class="type"><a href="Calendar_sig.S.html#TYPEt">Calendar_sig.S.t</a> -> int * int * int * <a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsafe_to_time"></a>safe_to_time : <code class="type">([< `Day | `Week ] as 'a) <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> 'a Time.Period.period</code></pre><div class="info"> +Equivalent to <a href="Calendar_sig.S.Period.html#VALto_time"><code class="code"><span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.to_time</code></a> but never raises any exception.<br> +<b>Since</b> 2.02<br> +</div> +<pre><span class="keyword">val</span> <a name="VALymds"></a>ymds : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> -><br> int * int * int * <a href="Calendar_sig.S.html#TYPEsecond">Calendar_sig.S.second</a></code></pre><div class="info"> Number of years, months, days and seconds in a period.<br> <b>Since</b> 1.09.0<br> <b>Examples:</b><ul><li><code class="code">ymds (make (-1) (-2) (-3) (-1) (-2) (-3)</code> returns diff --git a/doc/Calendar_sig.S.Time.html b/doc/Calendar_sig.S.Time.html index 0edef7c..3f3ef89 100644 --- a/doc/Calendar_sig.S.Time.html +++ b/doc/Calendar_sig.S.Time.html @@ -107,7 +107,7 @@ The current time based on <code class="code"><span class="constructor">Time_Zone <code class="code">convert t <span class="constructor">Time_Zone</span>.<span class="constructor">GMT</span> (<span class="constructor">Time_Zone</span>.current ())</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_gmt"></a>to_gmt : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -<code class="code">to_gmt t</code> is equivalent to +<code class="code">to_gmt t</code> is equivalent to <code class="code">convert t (<span class="constructor">Time_Zone</span>.current ()) <span class="constructor">Time_Zone</span>.<span class="constructor">GMT</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALnormalize"></a>normalize : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a> * int</code></pre><div class="info"> @@ -138,12 +138,12 @@ Number of seconds of a time.<br> <b>Example:</b> <code class="code">to_seconds (make 1 2 3)</code> returns <code class="code">3600 + 120 + 3 = 3723</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_minutes"></a>to_minutes : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Number of minutes of a time. The resulting fractional part represents +Number of minutes of a time. The resulting fractional part represents seconds.<br> <b>Example:</b> <code class="code">to_minutes (make 1 2 3)</code> returns <code class="code">60+2+0.05 = 62.05</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_hours"></a>to_hours : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Number of hours of a time. The resulting fractional part represents +Number of hours of a time. The resulting fractional part represents minutes and seconds.<br> <b>Example:</b> <code class="code">to_hours (make 1 3 0)</code> returns <code class="code">1 + 0.05 = 1.05</code>.<br> </div> @@ -170,13 +170,13 @@ Hash function for times.<br> <pre><span class="keyword">val</span> <a name="VALis_pm"></a>is_pm : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> Return <code class="code"><span class="keyword">true</span></code> is the time is before midday in the current time zone; <code class="code"><span class="keyword">false</span></code> otherwise.<br> -<b>Example:</b> both <code class="code">is_pm (make 10 0 0)</code> and <code class="code">is_pm (make 34 0 0)</code> return +<b>Example:</b> both <code class="code">is_pm (make 10 0 0)</code> and <code class="code">is_pm (make 34 0 0)</code> return <code class="code"><span class="keyword">true</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALis_am"></a>is_am : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> -Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; +Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; <code class="code"><span class="keyword">false</span></code> otherwise.<br> -<b>Example:</b> both <code class="code">is_am (make 20 0 0)</code> and <code class="code">is_am (make 44 0 0)</code> return +<b>Example:</b> both <code class="code">is_am (make 20 0 0)</code> and <code class="code">is_am (make 44 0 0)</code> return <code class="code"><span class="keyword">true</span></code>.<br> </div> <br> @@ -200,15 +200,15 @@ A period is the number of seconds between two times. <br> <a name="2_Arithmeticoperationsontimesandperiods"></a> <h2>Arithmetic operations on times and periods</h2><br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <code class="code">app t p</code> returns <code class="code">t + p</code>.<br> <b>Example:</b> <code class="code">add (make 20 0 0) (<span class="constructor">Period</span>.minute 70)</code> returns the time 21:10:0.<br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> <a href="Time_sig.S.html#TYPEt">t</a> -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period</code></pre><div class="info"> <code class="code">sub t1 t2</code> returns the period between <code class="code">t1</code> and <code class="code">t2</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <code class="code">rem t p</code> is equivalent to <code class="code">add t (<span class="constructor">Period</span>.opp p)</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEfield">field</a> -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Calendar_sig.S.html b/doc/Calendar_sig.S.html index eb35161..5408c02 100644 --- a/doc/Calendar_sig.S.html +++ b/doc/Calendar_sig.S.html @@ -44,17 +44,14 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> -<div class="info"> -Type of a date refined with a time, so called a calendar.<br> -</div> - <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Date.html">Date</a>: <code class="type"><a href="Date_sig.S.html">Date_sig.S</a></code><code class="type"> </code></pre><div class="info"> Date implementation used by this calendar. </div> <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Time.html">Time</a>: <code class="type"><a href="Time_sig.S.html">Time_sig.S</a></code><code class="type"> </code></pre><div class="info"> Time implementation used by this calendar. </div> +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> + <pre><span class="keyword">type</span> <a name="TYPEday"></a><code class="type"></code>day = <code class="type">Date.day</code> = </pre><table class="typetable"> <tr> <td align="left" valign="top" > @@ -218,8 +215,8 @@ The different fields of a calendar.<br> </ul> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. - The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> +Labelled version of <code class="code">make</code>. + The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> and <code class="code">second</code>) is <code class="code">1</code> (resp. <code class="code">0</code>).<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>D.Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -235,8 +232,8 @@ Labelled version of <code class="code">make</code>. zone).<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_jd"></a>from_jd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Return the Julian day. - More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the +Return the Julian day. + More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the time.<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_mjd"></a>from_mjd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> @@ -286,7 +283,7 @@ Those functions have the same behavious as those defined in <b>See also</b> <a href="Date_sig.S.html#VALyear">Date_sig.S.year</a><br> </div> <br> -<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and +<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and <a href="Date_sig.S.html#VALto_mjd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_mjd</code></a>.<br> <pre><span class="keyword">val</span> <a name="VALto_jd"></a>to_jd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><pre><span class="keyword">val</span> <a name="VALto_mjd"></a>to_mjd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><br> Those functions have the same behavious as those defined in @@ -347,15 +344,15 @@ Convert a calendar into the <code class="code">unix.tm</code> type. <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_unixtm"></a>from_unixtm : <code class="type">Unix.tm -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. +Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. So, The following invariant holds: <code class="code">hour (from_unixtm u) = u.<span class="constructor">Unix</span>.tm_hour</code>.<br> <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. - So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. + So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. More precise than <a href="Date_sig.S.html#VALto_unixfloat"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_unixfloat</code></a>.<br> <b>Since</b> 1.01<br> </div> @@ -366,7 +363,7 @@ Inverse of <code class="code">to_unixfloat</code>. Assumes the current time zone <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Convert a date to a calendar. +Convert a date to a calendar. The time is midnight in the current time zone.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Date.t</code></pre><div class="info"> @@ -388,13 +385,17 @@ A period is the number of seconds between two calendars. <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALadd">Date_sig.S.add</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> <a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALsub">Date_sig.S.sub</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">Period.t</a></code></pre><div class="info"> +<b>Since</b> 2.03<br> +<b>See also</b> <a href="Date_sig.S.html#VALprecise_sub">Date_sig.S.precise_sub</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALrem">Date_sig.S.rem</a><br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEfield">field</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Date_sig.S.Period.html b/doc/Date_sig.S.Period.html index a6a0990..05ab22f 100644 --- a/doc/Date_sig.S.Period.html +++ b/doc/Date_sig.S.Period.html @@ -38,6 +38,8 @@ <br> <a name="3_Arithmeticoperations"></a> <h3>Arithmetic operations</h3><br> +<pre><span class="keyword">type</span> <a name="TYPEp"></a><code class="type">+[< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> ]</code> p </pre> + <pre><span class="keyword">include</span> <a href="Period.S.html">Period.S</a></pre> <br> <a name="3_Constructors"></a> @@ -46,19 +48,19 @@ <code class="code">make year month day</code> makes a period of the specified length.<br> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">?year:int -> ?month:int -> ?day:int -> unit -> <a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. +Labelled version of <code class="code">make</code>. The default value of each argument is <code class="code">0</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">int -> <a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">int -> [< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> > `Year ] period</code></pre><div class="info"> <code class="code">year n</code> makes a period of <code class="code">n</code> years.<br> </div> -<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">int -> <a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">int -> [< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> > `Month `Year ] period</code></pre><div class="info"> <code class="code">month n</code> makes a period of <code class="code">n</code> months.<br> </div> -<pre><span class="keyword">val</span> <a name="VALweek"></a>week : <code class="type">int -> <a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALweek"></a>week : <code class="type">int -> [< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> > `Day `Week ] period</code></pre><div class="info"> <code class="code">week n</code> makes a period of <code class="code">n</code> weeks.<br> </div> -<pre><span class="keyword">val</span> <a name="VALday"></a>day : <code class="type">int -> <a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALday"></a>day : <code class="type">int -> [< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> > `Day `Week ] period</code></pre><div class="info"> <code class="code">day n</code> makes a period of <code class="code">n</code> days.<br> </div> <br> @@ -68,7 +70,8 @@ Labelled version of <code class="code">make</code>. <div class="info"> <b>Since</b> 1.04<br> </div> -<pre><span class="keyword">val</span> <a name="VALnb_days"></a>nb_days : <code class="type"><a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALnb_days"></a>nb_days : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> ] period -> int</code></pre><div class="info"> +<span class="warning">Deprecated.</span>since 2.02: use <a href="Date_sig.S.Period.html#VALsafe_nb_days"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.safe_nb_days</code></a> instead<br> Number of days in a period.<br> <b>Since</b> 1.04<br> <b>Raises</b> <code>Not_computable</code> if the number of days is not computable.<br> @@ -76,7 +79,11 @@ Number of days in a period.<br> not a constant number of days.<br> </li><li><code class="code">nb_days (day 6)</code> returns <code class="code">6</code><br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALymd"></a>ymd : <code class="type"><a href="Date_sig.S.html#TYPEt">Date_sig.S.t</a> -> int * int * int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsafe_nb_days"></a>safe_nb_days : <code class="type">[< `Day | `Week ] period -> int</code></pre><div class="info"> +Equivalent to <a href="Date_sig.S.Period.html#VALnb_days"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.nb_days</code></a> but never raises any exception.<br> +<b>Since</b> 2.02<br> +</div> +<pre><span class="keyword">val</span> <a name="VALymd"></a>ymd : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">Date_sig.S.field</a> ] period -> int * int * int</code></pre><div class="info"> Number of years, months and days in a period.<br> <b>Since</b> 1.09.0<br> <b>Example:</b> <code class="code">ymd (make 1 2 3)</code> returns <code class="code">1, 2, 3</code>.<br> diff --git a/doc/Date_sig.S.html b/doc/Date_sig.S.html index f56b083..e887169 100644 --- a/doc/Date_sig.S.html +++ b/doc/Date_sig.S.html @@ -46,7 +46,19 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> +<pre><span class="keyword">type</span> <a name="TYPEfield"></a><code class="type"></code>field = <code class="type"><a href="Period.html#TYPEdate_field">Period.date_field</a></code> </pre> +<div class="info"> +The different fields of a date.<br> +<b>Since</b> 2.02<br> +</div> + +<pre><span class="keyword">type</span> <a name="TYPEdate"></a><code class="type">-[< <a href="Date_sig.S.html#TYPEfield">field</a> ]</code> date </pre> +<div class="info"> +Type of a date, without specifying any precision level.<br> +<b>Since</b> 2.02<br> +</div> + +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t = <code class="type"><a href="Date_sig.S.html#TYPEfield">field</a> <a href="Date_sig.S.html#TYPEdate">date</a></code> </pre> <div class="info"> Type of a date.<br> </div> @@ -201,11 +213,6 @@ Months of the year.<br> Year as an <code class="code">int</code>.<br> </div> -<pre><span class="keyword">type</span> <a name="TYPEfield"></a><code class="type"></code>field = <code class="type">[ `Day | `Month | `Week | `Year ]</code> </pre> -<div class="info"> -The different fields of a date.<br> -</div> - <br> <a name="2_Exceptions"></a> <h2>Exceptions</h2><br> @@ -215,7 +222,7 @@ Raised when a date is outside the Julian period.<br> </div> <pre><span class="keyword">exception</span> <a name="EXCEPTIONUndefined"></a>Undefined</pre> <div class="info"> -Raised when a date belongs to +Raised when a date belongs to <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code>.<br> </div> <br> @@ -232,7 +239,7 @@ Raised when a date belongs to (-4) and 0.<br> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:<a href="Date_sig.S.html#TYPEyear">year</a> -> ?month:int -> ?day:int -> unit -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. +Labelled version of <code class="code">make</code>. The default value of <code class="code">month</code> and <code class="code">day</code> is <code class="code">1</code>.<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -240,6 +247,16 @@ Labelled version of <code class="code">make</code>. 14th, 1582]</code>.</li> </ul> </div> +<pre><span class="keyword">val</span> <a name="VALmake_year"></a>make_year : <code class="type">int -> [< `Year ] <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">make_year y</code> makes a date only represented by its year <code class="code">y</code>. The month + and the day of such a date are not relevant.<br> +<b>Since</b> 2.02<br> +</div> +<pre><span class="keyword">val</span> <a name="VALmake_year_month"></a>make_year_month : <code class="type">int -> int -> [< `Month | `Year ] <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">make_year_month y m</code> makes a date only represented by its year <code class="code">y</code> and + its month <code class="code">m</code>. The day of such a date is not relevant.<br> +<b>Since</b> 2.02<br> +</div> <pre><span class="keyword">val</span> <a name="VALtoday"></a>today : <code class="type">unit -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> Date of the current day (based on <code class="code"><span class="constructor">Time_Zone</span>.current ()</code>).<br> </div> @@ -260,7 +277,7 @@ Make a date from a year and its day of the year.<br> <br> <a name="2_Getters"></a> <h2>Getters</h2><br> -<pre><span class="keyword">val</span> <a name="VALdays_in_month"></a>days_in_month : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALdays_in_month"></a>days_in_month : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Month `Year ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Number of days in the month of a date.<br> <b>Example:</b> <code class="code">days_in_month (make 2003 6 26)</code> returns <code class="code">30</code>.<br> </div> @@ -284,11 +301,11 @@ Week.<br> </li><li><code class="code">week (make 2000 1 2)</code> returns <code class="code">52</code>.<br> </li><li><code class="code">week (make 2000 1 3)</code> returns <code class="code">1</code>.<br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEmonth">month</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmonth"></a>month : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Month ] <a href="Date_sig.S.html#TYPEdate">date</a> -> <a href="Date_sig.S.html#TYPEmonth">month</a></code></pre><div class="info"> Month.<br> <b>Example:</b> <code class="code">month (make 2003 6 26)</code> returns <code class="code"><span class="constructor">Jun</span></code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEyear">year</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALyear"></a>year : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> > `Year ] <a href="Date_sig.S.html#TYPEdate">date</a> -> <a href="Date_sig.S.html#TYPEyear">year</a></code></pre><div class="info"> Year.<br> <b>Example:</b> <code class="code">year (make 2003 6 26)</code> returns <code class="code">2003</code>.<br> </div> @@ -304,16 +321,16 @@ Modified Julian day (i.e. Julian day - 2 400 001). <br> <a name="2_Datesarecomparable"></a> <h2>Dates are comparable</h2><br> -<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> bool</code></pre><div class="info"> Equality function between two dates.<br> <b>Since</b> 1.09.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALequal">Utils.Comparable.equal</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Comparison function between two dates.<br> <b>See also</b> <a href="Utils.Comparable.html#VALcompare">Utils.Comparable.compare</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type">[< <a href="Date_sig.S.html#TYPEfield">field</a> ] <a href="Date_sig.S.html#TYPEdate">date</a> -> int</code></pre><div class="info"> Hash function for dates.<br> <b>Since</b> 2.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALhash">Utils.Comparable.hash</a><br> @@ -344,8 +361,8 @@ Return <code class="code"><span class="keyword">true</span></code> iff a date be <a name="2_Coercions"></a> <h2>Coercions</h2><br> <pre><span class="keyword">val</span> <a name="VALto_unixtm"></a>to_unixtm : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Unix.tm</code></pre><div class="info"> -Convert a date into the <code class="code"><span class="constructor">Unix</span>.tm</code> type. - The field <code class="code">is_isdst</code> is always <code class="code"><span class="keyword">false</span></code>. The fields <code class="code"><span class="constructor">Unix</span>.tm_sec</code>, +Convert a date into the <code class="code"><span class="constructor">Unix</span>.tm</code> type. + The field <code class="code">is_isdst</code> is always <code class="code"><span class="keyword">false</span></code>. The fields <code class="code"><span class="constructor">Unix</span>.tm_sec</code>, <code class="code"><span class="constructor">Unix</span>.tm_min</code> and <code class="code"><span class="constructor">Unix</span>.tm_hour</code> are irrelevant.<br> <b>Since</b> 1.01<br> </div> @@ -354,8 +371,8 @@ Inverse of <code class="code">to_unixtm</code>. Assume the current time zone.<br <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> - returns <code class="code">0.0</code>. So such a float is convertible with those of the <code class="code"><span class="constructor">Unix</span></code> +Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> + returns <code class="code">0.0</code>. So such a float is convertible with those of the <code class="code"><span class="constructor">Unix</span></code> module. The fractional part of the result is always <code class="code">0</code>.<br> <b>Since</b> 1.01<br> </div> @@ -406,22 +423,32 @@ A period is the number of days between two dates. <br> <a name="2_Arithmeticoperationsondatesandperiods"></a> <h2>Arithmetic operations on dates and periods</h2><br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a Period.period -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">add d p</code> returns <code class="code">d + p</code>.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> <li><code>Undefined</code> when the resulting date belongs to <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code>.</li> </ul> -<b>Examples:</b><ul><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 2)</code> returns the date +<b>Examples:</b><ul><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 2)</code> returns the date 2004-3-2 (following the coercion rule describes in the introduction).<br> -</li><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 1)</code> returns the date +</li><li><code class="code">add (make 2003 12 31) (<span class="constructor">Period</span>.month 1)</code> returns the date 2004-1-31<br> </li></ul></div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a <a href="Date_sig.S.html#TYPEdate">date</a> -><br> [< <a href="Date_sig.S.html#TYPEfield">field</a> > `Day `Week ] Period.period</code></pre><div class="info"> <code class="code">sub d1 d2</code> returns the period between <code class="code">d1</code> and <code class="code">d2</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a <a href="Date_sig.S.html#TYPEdate">date</a> -> Period.t</code></pre><div class="info"> +<code class="code">precise_sub d1 d2</code> returns the period between <code class="code">d1</code> and <code class="code">d2</code>. + It is equivalent to <code class="code">sub</code>, but:<ul> +<li>the period is expressed with a number of years, months and days, not + only with a number of days;</li> +<li>it is less efficient.</li> +</ul> +<br> +<b>Since</b> 2.03<br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -><br> 'a Period.period -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">rem d p</code> is equivalent to <code class="code">add d (<span class="constructor">Period</span>.opp p)</code>.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -429,7 +456,7 @@ A period is the number of days between two dates. 1582; <span class="constructor">October</span> 14th, 1582]</code>.</li> </ul> </div> -<pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEfield">field</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -> 'a -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> <code class="code">next d f</code> returns the date corresponding to the next specified field.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -439,8 +466,8 @@ A period is the number of days between two dates. <b>Example:</b> <code class="code">next (make 2003 12 31) <span class="keywordsign">`</span><span class="constructor">Month</span></code> returns the date 2004-1-31 (i.e. one month later).<br> </div> -<pre><span class="keyword">val</span> <a name="VALprev"></a>prev : <code class="type"><a href="Date_sig.S.html#TYPEt">t</a> -> <a href="Date_sig.S.html#TYPEfield">field</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -<code class="code">prev d f</code> returns the date corresponding to the previous specified +<pre><span class="keyword">val</span> <a name="VALprev"></a>prev : <code class="type">([< <a href="Date_sig.S.html#TYPEfield">field</a> ] as 'a) <a href="Date_sig.S.html#TYPEdate">date</a> -> 'a -> 'a <a href="Date_sig.S.html#TYPEdate">date</a></code></pre><div class="info"> +<code class="code">prev d f</code> returns the date corresponding to the previous specified field.<br> <b>Raises</b><ul><li><code>Out_of_bounds</code> when the resulting date is outside the Julian period.</li> @@ -461,7 +488,7 @@ Return <code class="code"><span class="keyword">true</span></code> if two years otherwise.<br> </div> <pre><span class="keyword">val</span> <a name="VALdays_in_year"></a>days_in_year : <code class="type">?month:<a href="Date_sig.S.html#TYPEmonth">month</a> -> <a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Number of days in a year. +Number of days in a year. <p> <code class="code">days_in_year ~month y</code> returns the number of days in the year <code class="code">y</code> up @@ -491,42 +518,42 @@ Millenium of a year.<br> </li><li><code class="code">millenium 2000</code> returns 2<br> </li></ul></div> <pre><span class="keyword">val</span> <a name="VALsolar_number"></a>solar_number : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Solar number. +Solar number. <p> In the Julian calendar there is a one-to-one relationship between the Solar number and the day on which a particular date falls.<br> </div> <pre><span class="keyword">val</span> <a name="VALindiction"></a>indiction : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Indiction. +Indiction. <p> - The Indiction was used in the middle ages to specify the position of a + The Indiction was used in the middle ages to specify the position of a year in a 15 year taxation cycle. It was introduced by emperor Constantine the Great on 1 September 312 and ceased to be used in - 1806. + 1806. <p> The Indiction has no astronomical significance.<br> </div> <pre><span class="keyword">val</span> <a name="VALgolden_number"></a>golden_number : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Golden number. +Golden number. <p> Considering that the relationship between the moon's phases and the days of the year repeats itself every 19 years, it is natural to - associate a number between 1 and 19 with each year. + associate a number between 1 and 19 with each year. This number is the so-called Golden number.<br> </div> <pre><span class="keyword">val</span> <a name="VALepact"></a>epact : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> int</code></pre><div class="info"> -Epact. +Epact. <p> - The Epact is a measure of the age of the moon (i.e. the number of days + The Epact is a measure of the age of the moon (i.e. the number of days that have passed since an "official" new moon) on a particular date.<br> </div> <pre><span class="keyword">val</span> <a name="VALeaster"></a>easter : <code class="type"><a href="Date_sig.S.html#TYPEyear">year</a> -> <a href="Date_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Easter Sunday. +Easter Sunday. <p> In the Christian world, Easter (and the days immediately preceding it) diff --git a/doc/Date_sig.html b/doc/Date_sig.html index 4bb72dc..531f0bb 100644 --- a/doc/Date_sig.html +++ b/doc/Date_sig.html @@ -34,24 +34,24 @@ </div> <center><h1>Module <a href="type_Date_sig.html">Date_sig</a></h1></center> <br> -<pre><span class="keyword">module</span> Date_sig: <code class="code"><span class="keyword">sig</span></code> <a href="Date_sig.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Date interface. A date may be seen as a triple (year, month, day). +<pre><span class="keyword">module</span> Date_sig: <code class="code"><span class="keyword">sig</span></code> <a href="Date_sig.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Date interface. A date may be seen as a triple (year, month, day). <p> - All the dates should belong to + All the dates should belong to <code class="code">[<span class="constructor">January</span>, 1st 4713 <span class="constructor">BC</span>; <span class="constructor">January</span> 22th, 3268 <span class="constructor">AC</span>]</code> (called the Julian period). - An <code class="code"><span class="constructor">Out_of_bounds</span></code> exception is raised if you attempt to create a date + An <code class="code"><span class="constructor">Out_of_bounds</span></code> exception is raised if you attempt to create a date outside the Julian period. <p> - If a date <code class="code">d</code> does not exists and if <code class="code">d_bef</code> (resp. <code class="code">d_aft</code>) is - the last (resp. first) existing date before (resp. after) <code class="code">d</code>, + If a date <code class="code">d</code> does not exists and if <code class="code">d_bef</code> (resp. <code class="code">d_aft</code>) is + the last (resp. first) existing date before (resp. after) <code class="code">d</code>, <code class="code">d</code> is automatically coerced to <code class="code">d_aft + d - d_bef - 1</code>. - For example, both dates "February 29th, 2003" and - "February 30th, 2003" do not exist and they are coerced respectively to the - date "Mars 1st, 2003" and "Mars 2nd, 2003". + For example, both dates "February 29th, 2003" and + "February 30th, 2003" do not exist and they are coerced respectively to the + date "Mars 1st, 2003" and "Mars 2nd, 2003". This rule is called the coercion rule. - As an exception to the coercion rule, the date belonging to - <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code> do not exist and an <code class="code"><span class="constructor">Undefined</span></code> + As an exception to the coercion rule, the date belonging to + <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code> do not exist and an <code class="code"><span class="constructor">Undefined</span></code> exception is raised if you attempt to create such a date. Those dropped days correspond to the change from the Julian to the Gregorian calendar.<br> diff --git a/doc/Fcalendar.Precise.html b/doc/Fcalendar.Precise.html index f7a1e17..5374b89 100644 --- a/doc/Fcalendar.Precise.html +++ b/doc/Fcalendar.Precise.html @@ -44,17 +44,14 @@ <br> <a name="2_Datatypes"></a> <h2>Datatypes</h2><br> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> -<div class="info"> -Type of a date refined with a time, so called a calendar.<br> -</div> - <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Date.html">Date</a>: <code class="type"><a href="Date_sig.S.html">Date_sig.S</a></code><code class="type"> </code></pre><div class="info"> Date implementation used by this calendar. </div> <pre><span class="keyword">module</span> <a href="Calendar_sig.S.Time.html">Time</a>: <code class="type"><a href="Time_sig.S.html">Time_sig.S</a></code><code class="type"> </code></pre><div class="info"> Time implementation used by this calendar. </div> +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> + <pre><span class="keyword">type</span> <a name="TYPEday"></a><code class="type"></code>day = <code class="type">Date.day</code> = </pre><table class="typetable"> <tr> <td align="left" valign="top" > @@ -218,8 +215,8 @@ The different fields of a calendar.<br> </ul> </div> <pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">year:int -><br> ?month:int -><br> ?day:int -><br> ?hour:int -><br> ?minute:int -> ?second:<a href="Calendar_sig.S.html#TYPEsecond">second</a> -> unit -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. - The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> +Labelled version of <code class="code">make</code>. + The default value of <code class="code">month</code> and <code class="code">day</code> (resp. of <code class="code">hour</code>, <code class="code">minute</code> and <code class="code">second</code>) is <code class="code">1</code> (resp. <code class="code">0</code>).<br> <b>Since</b> 1.05<br> <b>Raises</b><ul><li><code>D.Out_of_bounds</code> when a date is outside the Julian period.</li> @@ -235,8 +232,8 @@ Labelled version of <code class="code">make</code>. zone).<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_jd"></a>from_jd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Return the Julian day. - More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the +Return the Julian day. + More precise than <code class="code"><span class="constructor">Date</span>.from_jd</code>: the fractional part represents the time.<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_mjd"></a>from_mjd : <code class="type">float -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> @@ -286,7 +283,7 @@ Those functions have the same behavious as those defined in <b>See also</b> <a href="Date_sig.S.html#VALyear">Date_sig.S.year</a><br> </div> <br> -<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and +<code class="code">to_jd</code> and <code class="code">to_mjd</code> are more precise than <a href="Date_sig.S.html#VALto_jd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_jd</code></a> and <a href="Date_sig.S.html#VALto_mjd"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_mjd</code></a>.<br> <pre><span class="keyword">val</span> <a name="VALto_jd"></a>to_jd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><pre><span class="keyword">val</span> <a name="VALto_mjd"></a>to_mjd : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><br> Those functions have the same behavious as those defined in @@ -347,15 +344,15 @@ Convert a calendar into the <code class="code">unix.tm</code> type. <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_unixtm"></a>from_unixtm : <code class="type">Unix.tm -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. +Inverse of <code class="code">to_unixtm</code>. Assumes the current time zone. So, The following invariant holds: <code class="code">hour (from_unixtm u) = u.<span class="constructor">Unix</span>.tm_hour</code>.<br> <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALto_unixfloat"></a>to_unixfloat : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. - So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. + So such a float is convertible with those of the module <code class="code"><span class="constructor">Unix</span></code>. More precise than <a href="Date_sig.S.html#VALto_unixfloat"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.to_unixfloat</code></a>.<br> <b>Since</b> 1.01<br> </div> @@ -366,7 +363,7 @@ Inverse of <code class="code">to_unixfloat</code>. Assumes the current time zone <b>Since</b> 1.01<br> </div> <pre><span class="keyword">val</span> <a name="VALfrom_date"></a>from_date : <code class="type">Date.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -Convert a date to a calendar. +Convert a date to a calendar. The time is midnight in the current time zone.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_date"></a>to_date : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Date.t</code></pre><div class="info"> @@ -388,13 +385,17 @@ A period is the number of seconds between two calendars. <br> Those functions have the same behavious as those defined in <a href="Date_sig.S.html"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span></code></a>.<br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALadd">Date_sig.S.add</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> <a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> > `Day `Week ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALsub">Date_sig.S.sub</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALprecise_sub"></a>precise_sub : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.Period.html#TYPEt">Period.t</a></code></pre><div class="info"> +<b>Since</b> 2.03<br> +<b>See also</b> <a href="Date_sig.S.html#VALprecise_sub">Date_sig.S.precise_sub</a><br> +</div> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Calendar_sig.S.Period.html#TYPEperiod">Period.period</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <b>See also</b> <a href="Date_sig.S.html#VALrem">Date_sig.S.rem</a><br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Calendar_sig.S.html#TYPEt">t</a> -> <a href="Calendar_sig.S.html#TYPEfield">field</a> -> <a href="Calendar_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Fcalendar.html b/doc/Fcalendar.html index 19e9a25..aa245a5 100644 --- a/doc/Fcalendar.html +++ b/doc/Fcalendar.html @@ -38,7 +38,7 @@ <p> This module uses float. Then results may be very unprecise, especially - comparison of calendars which differ with few seconds. + comparison of calendars which differ with few seconds. In this case, consider to use module <code class="code"><span class="constructor">Precise</span></code>.<br> <b>Since</b> 2.0<br> <hr width="100%"> diff --git a/doc/Ftime.html b/doc/Ftime.html index 60d1cb8..66544c9 100644 --- a/doc/Ftime.html +++ b/doc/Ftime.html @@ -34,7 +34,7 @@ </div> <center><h1>Module <a href="type_Ftime.html">Ftime</a></h1></center> <br> -<pre><span class="keyword">module</span> Ftime: <code class="code"><span class="keyword">sig</span></code> <a href="Ftime.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Time implementation in which seconds are floats. +<pre><span class="keyword">module</span> Ftime: <code class="code"><span class="keyword">sig</span></code> <a href="Ftime.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Time implementation in which seconds are floats. <p> This module uses float. Then results may be very unprecise.<br> diff --git a/doc/Period.S.html b/doc/Period.S.html index 9fc32d3..75d8374 100644 --- a/doc/Period.S.html +++ b/doc/Period.S.html @@ -34,7 +34,9 @@ <br> <pre><span class="keyword">module type</span> S = <code class="code"><span class="keyword">sig</span></code> <a href="Period.S.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Common interface for all periods.<br> <hr width="100%"> -<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t </pre> +<pre><span class="keyword">type</span> <a name="TYPEperiod"></a><code class="type">+[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ]</code> period </pre> + +<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type"></code>t = <code class="type"><a href="Period.html#TYPEdate_field">Period.date_field</a> <a href="Period.S.html#TYPEperiod">period</a></code> </pre> <div class="info"> Type of a period.<br> </div> @@ -42,31 +44,31 @@ Type of a period.<br> <br> <a name="3_Periodisanadditivemonoid"></a> <h3>Period is an additive monoid</h3><br> -<pre><span class="keyword">val</span> <a name="VALempty"></a>empty : <code class="type"><a href="Period.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALempty"></a>empty : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a></code></pre><div class="info"> The empty period.<br> </div> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) <a href="Period.S.html#TYPEperiod">period</a> -><br> 'a <a href="Period.S.html#TYPEperiod">period</a> -> 'a <a href="Period.S.html#TYPEperiod">period</a></code></pre><div class="info"> Addition of periods.<br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) <a href="Period.S.html#TYPEperiod">period</a> -><br> 'a <a href="Period.S.html#TYPEperiod">period</a> -> 'a <a href="Period.S.html#TYPEperiod">period</a></code></pre><div class="info"> Substraction of periods.<br> </div> -<pre><span class="keyword">val</span> <a name="VALopp"></a>opp : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALopp"></a>opp : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) <a href="Period.S.html#TYPEperiod">period</a> -> 'a <a href="Period.S.html#TYPEperiod">period</a></code></pre><div class="info"> Opposite of a period.<br> </div> <br> <a name="3_Periodsarecomparable"></a> <h3>Periods are comparable</h3><br> -<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALequal"></a>equal : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a> -> bool</code></pre><div class="info"> Equality function between two periods.<br> <b>Since</b> 1.09.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALequal">Utils.Comparable.equal</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> <a href="Period.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a> -> int</code></pre><div class="info"> Comparison function between two periods.<br> <b>See also</b> <a href="Utils.Comparable.html#VALcompare">Utils.Comparable.compare</a><br> </div> -<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type"><a href="Period.S.html#TYPEt">t</a> -> int</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALhash"></a>hash : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] <a href="Period.S.html#TYPEperiod">period</a> -> int</code></pre><div class="info"> Hash function for periods.<br> <b>Since</b> 2.0<br> <b>See also</b> <a href="Utils.Comparable.html#VALhash">Utils.Comparable.hash</a><br> diff --git a/doc/Period.html b/doc/Period.html index 85d8079..0facf60 100644 --- a/doc/Period.html +++ b/doc/Period.html @@ -39,6 +39,8 @@ An implementation of this interface depends on the kind of an event (see module <code class="code"><span class="constructor">Time</span>.<span class="constructor">Period</span></code>, <code class="code"><span class="constructor">Date</span>.<span class="constructor">Period</span></code> and <code class="code"><span class="constructor">Calendar</span>.<span class="constructor">Period</span></code>).<br> <hr width="100%"> +<pre><span class="keyword">type</span> <a name="TYPEdate_field"></a><code class="type"></code>date_field = <code class="type">[ `Day | `Month | `Week | `Year ]</code> </pre> + <pre><span class="keyword">module type</span> <a href="Period.S.html">S</a> = <code class="code"><span class="keyword">sig</span></code> <a href="Period.S.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info"> Common interface for all periods. </div> diff --git a/doc/Printer.Calendar.html b/doc/Printer.Calendar.html index f6404a6..3f08151 100644 --- a/doc/Printer.Calendar.html +++ b/doc/Printer.Calendar.html @@ -52,7 +52,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.CalendarPrinter.html b/doc/Printer.CalendarPrinter.html index 695865c..db89c5c 100644 --- a/doc/Printer.CalendarPrinter.html +++ b/doc/Printer.CalendarPrinter.html @@ -51,7 +51,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Date.html b/doc/Printer.Date.html index 4154fd6..0bd90cf 100644 --- a/doc/Printer.Date.html +++ b/doc/Printer.Date.html @@ -52,7 +52,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.DatePrinter.html b/doc/Printer.DatePrinter.html index 422b4f7..c92d6a5 100644 --- a/doc/Printer.DatePrinter.html +++ b/doc/Printer.DatePrinter.html @@ -51,7 +51,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Fcalendar.html b/doc/Printer.Fcalendar.html index 534b969..d8daa1b 100644 --- a/doc/Printer.Fcalendar.html +++ b/doc/Printer.Fcalendar.html @@ -51,7 +51,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Ftime.html b/doc/Printer.Ftime.html index f06be12..e70ed76 100644 --- a/doc/Printer.Ftime.html +++ b/doc/Printer.Ftime.html @@ -55,7 +55,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Precise_Calendar.html b/doc/Printer.Precise_Calendar.html index 7b06e6d..60659e9 100644 --- a/doc/Printer.Precise_Calendar.html +++ b/doc/Printer.Precise_Calendar.html @@ -52,7 +52,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Precise_Fcalendar.html b/doc/Printer.Precise_Fcalendar.html index 8215ac5..8854f01 100644 --- a/doc/Printer.Precise_Fcalendar.html +++ b/doc/Printer.Precise_Fcalendar.html @@ -35,7 +35,7 @@ </div> <center><h1>Module <a href="type_Printer.Precise_Fcalendar.html">Printer.Precise_Fcalendar</a></h1></center> <br> -<pre><span class="keyword">module</span> Precise_Fcalendar: <code class="type"><a href="Printer.S.html">S</a></code><code class="type"> with type t = <a href="Fcalendar.Precise.html">Fcalendar.Precise</a>.t</code></pre>Precise Fcalendar printer. +<pre><span class="keyword">module</span> Precise_Fcalendar: <code class="type"><a href="Printer.S.html">S</a></code><code class="type"> with type t = <a href="Fcalendar.Precise.html">Fcalendar.Precise</a>.t</code></pre>Precise Fcalendar printer. Seconds are rounded to integers before pretty printing. Default format is <code class="code">%i %<span class="constructor">T</span></code>.<br> <b>Since</b> 2.0<br> @@ -54,7 +54,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.S.html b/doc/Printer.S.html index 000f4e7..094ade9 100644 --- a/doc/Printer.S.html +++ b/doc/Printer.S.html @@ -47,7 +47,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.Time.html b/doc/Printer.Time.html index 2ae7250..23fe92a 100644 --- a/doc/Printer.Time.html +++ b/doc/Printer.Time.html @@ -54,7 +54,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.TimePrinter.html b/doc/Printer.TimePrinter.html index a16e045..698c623 100644 --- a/doc/Printer.TimePrinter.html +++ b/doc/Printer.TimePrinter.html @@ -51,7 +51,7 @@ Generic type of a printer.<br> <code class="code">print format</code> is equivalent to <code class="code">fprint format <span class="constructor">Format</span>.std_formatter</code><br> </div> <pre><span class="keyword">val</span> <a name="VALdprint"></a>dprint : <code class="type"><a href="Printer.S.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations).<br> </div> <pre><span class="keyword">val</span> <a name="VALsprint"></a>sprint : <code class="type">string -> <a href="Printer.S.html#TYPEt">t</a> -> string</code></pre><div class="info"> diff --git a/doc/Printer.html b/doc/Printer.html index 72f5bea..7ef2977 100644 --- a/doc/Printer.html +++ b/doc/Printer.html @@ -36,22 +36,22 @@ </div> <center><h1>Module <a href="type_Printer.html">Printer</a></h1></center> <br> -<pre><span class="keyword">module</span> Printer: <code class="code"><span class="keyword">sig</span></code> <a href="Printer.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Pretty printing and parsing from string. +<pre><span class="keyword">module</span> Printer: <code class="code"><span class="keyword">sig</span></code> <a href="Printer.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Pretty printing and parsing from string. In the following, an "event" is either a date or a time or a calendar. <p> This module implements different printers: one for each kind of events. - The three printers have the same signature: + The three printers have the same signature: they mainly implement a <code class="code">fprint : string <span class="keywordsign">-></span> formatter <span class="keywordsign">-></span> t <span class="keywordsign">-></span> unit</code> function and a <code class="code">from_fstring : string <span class="keywordsign">-></span> string <span class="keywordsign">-></span> t</code> function. - The first one prints an event according to a format string - (see below for a description of such a format). + The first one prints an event according to a format string + (see below for a description of such a format). The second one converts a string to an event according to a format string. <p> - A format string follows the unix utility 'date' (with few modifications). - It is a string which contains two types of objects: plain characters and - conversion specifiers. Those specifiers are introduced by + A format string follows the unix utility 'date' (with few modifications). + It is a string which contains two types of objects: plain characters and + conversion specifiers. Those specifiers are introduced by a <code class="code">%</code> character and their meanings are:<ul> <li><code class="code">%%</code>: a literal <code class="code">%</code></li> <li><code class="code">%a</code>: short day name (by using a short version of <code class="code">day_name</code>)</li> @@ -89,11 +89,12 @@ <li><code class="code">%<span class="constructor">Y</span></code>: year (four digits)</li> <li><code class="code">%z</code>: time zone in the form +hhmm (e.g. -0400) (since version 2.01)</li> <li><code class="code">%:z</code>: time zone in the form +hh:mm (e.g. -04:00) (since version 2.01)</li> -<li><code class="code">%::z</code>: time zone in the form +hh:mm:ss (e.g. -04:00:00) (since version 2.01)</li> +<li><code class="code">%::z</code>: time zone in the form +hh:mm:ss (e.g. -04:00:00) + (since version 2.01)</li> <li><code class="code">%:::z</code>: time zone in the form +hh (e.g. -04) (since version 2.01)</li> </ul> - By default, date pads numeric fields with zeroes. Two special modifiers + By default, date pads numeric fields with zeroes. Two special modifiers between <code class="code"><span class="keywordsign">`</span>%<span class="keywordsign">'</span></code> and a numeric directive are recognized:<ul> <li><code class="code"><span class="string">'-'</span> (hyphen)</code>: do not pad the field</li> <li><code class="code"><span class="string">'_'</span> (underscore)</code>: pad the field with spaces</li> @@ -104,13 +105,13 @@ <br> <b>Since</b> 1.05<br> <b>Examples:</b><ul><li>a possible output of <code class="code">%c</code> is <code class="code"><span class="constructor">Thu</span> <span class="constructor">Sep</span> 18 14:10:51 2003</code>.<br> -</li><li>a possible output of <code class="code">the date is %<span class="constructor">B</span>, the %-dth</code> is +</li><li>a possible output of <code class="code">the date is %<span class="constructor">B</span>, the %-dth</code> is <code class="code">the date is <span class="constructor">January</span>, the 6th</code> is matched by ;<br> </li><li>a possible output of <code class="code">%<span class="constructor">D</span></code> is <code class="code">01/06/03</code><br> </li></ul><hr width="100%"> <br> <a name="2_Internationalization"></a> -<h2>Internationalization</h2> +<h2>Internationalization</h2> <p> You can manage the string representations of days and months. @@ -120,23 +121,23 @@ String representation of a day.<br> </div> <pre><span class="keyword">val</span> <a name="VALname_of_day"></a>name_of_day : <code class="type">Date.day -> string</code></pre><div class="info"> -<code class="code">name_of_day d</code> is equivalent to <code class="code">!day_name d</code>. +<code class="code">name_of_day d</code> is equivalent to <code class="code">!day_name d</code>. Used by the specifier <code class="code">%<span class="constructor">A</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALshort_name_of_day"></a>short_name_of_day : <code class="type">Date.day -> string</code></pre><div class="info"> -<code class="code">short_name_of_day d</code> returns the 3 first characters of <code class="code">name_of_day d</code>. +<code class="code">short_name_of_day d</code> returns the 3 first characters of <code class="code">name_of_day d</code>. Used by the specifier <code class="code">%a</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALmonth_name"></a>month_name : <code class="type">(Date.month -> string) Pervasives.ref</code></pre><div class="info"> String representation of a month.<br> </div> <pre><span class="keyword">val</span> <a name="VALname_of_month"></a>name_of_month : <code class="type">Date.month -> string</code></pre><div class="info"> -<code class="code">name_of_month m</code> is equivalent to <code class="code">!day_month m</code>. +<code class="code">name_of_month m</code> is equivalent to <code class="code">!day_month m</code>. Used by the specifier <code class="code">%<span class="constructor">B</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALshort_name_of_month"></a>short_name_of_month : <code class="type">Date.month -> string</code></pre><div class="info"> -<code class="code">short_name_of_month d</code> returns the 3 first characters of - <code class="code">name_of_month d</code>. +<code class="code">short_name_of_month d</code> returns the 3 first characters of + <code class="code">name_of_month d</code>. Used by the specifier <code class="code">%b</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALset_word_regexp"></a>set_word_regexp : <code class="type">Str.regexp -> unit</code></pre><div class="info"> diff --git a/doc/Time_Zone.html b/doc/Time_Zone.html index b857d3c..3ea9185 100644 --- a/doc/Time_Zone.html +++ b/doc/Time_Zone.html @@ -70,7 +70,7 @@ Type of a time zone.<br> Return the current time zone. It is <code class="code"><span class="constructor">UTC</span></code> before any change.<br> </div> <pre><span class="keyword">val</span> <a name="VALchange"></a>change : <code class="type"><a href="Time_Zone.html#TYPEt">t</a> -> unit</code></pre><div class="info"> -Change the current time zone by another one. +Change the current time zone by another one. Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the specified time zone is <code class="code"><span class="constructor">UTC_Plus</span> x</code> with <code class="code">x < -12</code> or <code class="code">x > 11</code><br> </div> diff --git a/doc/Time_sig.S.Period.html b/doc/Time_sig.S.Period.html index 39ff52f..52dee95 100644 --- a/doc/Time_sig.S.Period.html +++ b/doc/Time_sig.S.Period.html @@ -41,50 +41,50 @@ <a name="3_Arithmeticoperations"></a> <h3>Arithmetic operations</h3><br> <pre><span class="keyword">include</span> <a href="Period.S.html">Period.S</a></pre> -<pre><span class="keyword">val</span> <a name="VALlength"></a>length : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALlength"></a>length : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a></code></pre><div class="info"> Number of seconds of a period.<br> </div> -<pre><span class="keyword">val</span> <a name="VALmul"></a>mul : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmul"></a>mul : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) period -> 'a period -> 'a period</code></pre><div class="info"> Multiplication.<br> </div> -<pre><span class="keyword">val</span> <a name="VALdiv"></a>div : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALdiv"></a>div : <code class="type">([< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] as 'a) period -> 'a period -> 'a period</code></pre><div class="info"> Division.<br> </div> <br> <a name="3_Constructors"></a> <h3>Constructors</h3><br> -<pre><span class="keyword">val</span> <a name="VALmake"></a>make : <code class="type">int -> int -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALmake"></a>make : <code class="type">int -> int -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period</code></pre><div class="info"> <code class="code">make hour minute second</code> makes a period of the specified length.<br> </div> -<pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">?hour:int -> ?minute:int -> ?second:<a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> unit -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> -Labelled version of <code class="code">make</code>. +<pre><span class="keyword">val</span> <a name="VALlmake"></a>lmake : <code class="type">?hour:int -><br> ?minute:int -><br> ?second:<a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> unit -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period</code></pre><div class="info"> +Labelled version of <code class="code">make</code>. The default value is <code class="code">0</code> for each argument.<br> </div> -<pre><span class="keyword">val</span> <a name="VALhour"></a>hour : <code class="type">int -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALhour"></a>hour : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period</code></pre><div class="info"> <code class="code">hour n</code> makes a period of <code class="code">n</code> hours.<br> </div> -<pre><span class="keyword">val</span> <a name="VALminute"></a>minute : <code class="type">int -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALminute"></a>minute : <code class="type">int -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period</code></pre><div class="info"> <code class="code">minute n</code> makes a period of <code class="code">n</code> minutes.<br> </div> -<pre><span class="keyword">val</span> <a name="VALsecond"></a>second : <code class="type"><a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> <a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsecond"></a>second : <code class="type"><a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a> -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period</code></pre><div class="info"> <code class="code">second n</code> makes a period of <code class="code">n</code> seconds.<br> </div> <br> <a name="3_Getters"></a> <h3>Getters</h3><br> -<pre><span class="keyword">val</span> <a name="VALto_seconds"></a>to_seconds : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALto_seconds"></a>to_seconds : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period -> <a href="Time_sig.S.html#TYPEsecond">Time_sig.S.second</a></code></pre><div class="info"> Number of seconds of a period.<br> <b>Since</b> 1.04<br> <b>Example:</b> <code class="code">to_seconds (make 1 2 3)</code> returns <code class="code">3600 + 120 + 3 = 3723</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALto_minutes"></a>to_minutes : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> float</code></pre><div class="info"> -Number of minutes of a period. The resulting fractional part +<pre><span class="keyword">val</span> <a name="VALto_minutes"></a>to_minutes : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period -> float</code></pre><div class="info"> +Number of minutes of a period. The resulting fractional part represents seconds.<br> <b>Since</b> 1.04<br> <b>Example:</b> <code class="code">to_minutes (make 1 2 3)</code> returns <code class="code">60 + 2 + 0.05 = 62.05</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALto_hours"></a>to_hours : <code class="type"><a href="Time_sig.S.html#TYPEt">Time_sig.S.t</a> -> float</code></pre><div class="info"> -Number of hours of a period. The resulting fractional part represents +<pre><span class="keyword">val</span> <a name="VALto_hours"></a>to_hours : <code class="type">[< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] period -> float</code></pre><div class="info"> +Number of hours of a period. The resulting fractional part represents minutes and seconds.<br> <b>Since</b> 1.04<br> <b>Example:</b> <code class="code">to_hours (make 1 3 0)</code> returns <code class="code">1 + 0.05 = 1.05</code>.<br> diff --git a/doc/Time_sig.S.html b/doc/Time_sig.S.html index 77d9044..4e30871 100644 --- a/doc/Time_sig.S.html +++ b/doc/Time_sig.S.html @@ -105,7 +105,7 @@ The current time based on <code class="code"><span class="constructor">Time_Zone <code class="code">convert t <span class="constructor">Time_Zone</span>.<span class="constructor">GMT</span> (<span class="constructor">Time_Zone</span>.current ())</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_gmt"></a>to_gmt : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> -<code class="code">to_gmt t</code> is equivalent to +<code class="code">to_gmt t</code> is equivalent to <code class="code">convert t (<span class="constructor">Time_Zone</span>.current ()) <span class="constructor">Time_Zone</span>.<span class="constructor">GMT</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALnormalize"></a>normalize : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a> * int</code></pre><div class="info"> @@ -136,12 +136,12 @@ Number of seconds of a time.<br> <b>Example:</b> <code class="code">to_seconds (make 1 2 3)</code> returns <code class="code">3600 + 120 + 3 = 3723</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_minutes"></a>to_minutes : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Number of minutes of a time. The resulting fractional part represents +Number of minutes of a time. The resulting fractional part represents seconds.<br> <b>Example:</b> <code class="code">to_minutes (make 1 2 3)</code> returns <code class="code">60+2+0.05 = 62.05</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALto_hours"></a>to_hours : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> float</code></pre><div class="info"> -Number of hours of a time. The resulting fractional part represents +Number of hours of a time. The resulting fractional part represents minutes and seconds.<br> <b>Example:</b> <code class="code">to_hours (make 1 3 0)</code> returns <code class="code">1 + 0.05 = 1.05</code>.<br> </div> @@ -168,13 +168,13 @@ Hash function for times.<br> <pre><span class="keyword">val</span> <a name="VALis_pm"></a>is_pm : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> Return <code class="code"><span class="keyword">true</span></code> is the time is before midday in the current time zone; <code class="code"><span class="keyword">false</span></code> otherwise.<br> -<b>Example:</b> both <code class="code">is_pm (make 10 0 0)</code> and <code class="code">is_pm (make 34 0 0)</code> return +<b>Example:</b> both <code class="code">is_pm (make 10 0 0)</code> and <code class="code">is_pm (make 34 0 0)</code> return <code class="code"><span class="keyword">true</span></code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALis_am"></a>is_am : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> bool</code></pre><div class="info"> -Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; +Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; <code class="code"><span class="keyword">false</span></code> otherwise.<br> -<b>Example:</b> both <code class="code">is_am (make 20 0 0)</code> and <code class="code">is_am (make 44 0 0)</code> return +<b>Example:</b> both <code class="code">is_am (make 20 0 0)</code> and <code class="code">is_am (make 44 0 0)</code> return <code class="code"><span class="keyword">true</span></code>.<br> </div> <br> @@ -198,15 +198,15 @@ A period is the number of seconds between two times. <br> <a name="2_Arithmeticoperationsontimesandperiods"></a> <h2>Arithmetic operations on times and periods</h2><br> -<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALadd"></a>add : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <code class="code">app t p</code> returns <code class="code">t + p</code>.<br> <b>Example:</b> <code class="code">add (make 20 0 0) (<span class="constructor">Period</span>.minute 70)</code> returns the time 21:10:0.<br> </div> -<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEt">t</a> -> Period.t</code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> <a href="Time_sig.S.html#TYPEt">t</a> -> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period</code></pre><div class="info"> <code class="code">sub t1 t2</code> returns the period between <code class="code">t1</code> and <code class="code">t2</code>.<br> </div> -<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> Period.t -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> +<pre><span class="keyword">val</span> <a name="VALrem"></a>rem : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -><br> [< <a href="Period.html#TYPEdate_field">Period.date_field</a> ] Period.period -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> <code class="code">rem t p</code> is equivalent to <code class="code">add t (<span class="constructor">Period</span>.opp p)</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALnext"></a>next : <code class="type"><a href="Time_sig.S.html#TYPEt">t</a> -> <a href="Time_sig.S.html#TYPEfield">field</a> -> <a href="Time_sig.S.html#TYPEt">t</a></code></pre><div class="info"> diff --git a/doc/Time_sig.html b/doc/Time_sig.html index b0ffbd2..1f9c958 100644 --- a/doc/Time_sig.html +++ b/doc/Time_sig.html @@ -34,7 +34,7 @@ </div> <center><h1>Module <a href="type_Time_sig.html">Time_sig</a></h1></center> <br> -<pre><span class="keyword">module</span> Time_sig: <code class="code"><span class="keyword">sig</span></code> <a href="Time_sig.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Time interface. A time may be seen as a triple (hour, minute, second). +<pre><span class="keyword">module</span> Time_sig: <code class="code"><span class="keyword">sig</span></code> <a href="Time_sig.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Time interface. A time may be seen as a triple (hour, minute, second). <p> If minutes and seconds do not belong to <code class="code">[0; 60[</code>, they are coerced into @@ -43,10 +43,10 @@ minute, 20 seconds". <p> - Each time is interpreted in the current time zone (given by - <code class="code"><span class="constructor">Time_Zone</span>.current ()</code>). So, if you change the time zone (by - <a href="Time_Zone.html#VALchange"><code class="code"><span class="constructor">Time_Zone</span>.change</code></a>), each time consequently changes. - If you want to express a time in another time zone (and do not affect + Each time is interpreted in the current time zone (given by + <code class="code"><span class="constructor">Time_Zone</span>.current ()</code>). So, if you change the time zone (by + <a href="Time_Zone.html#VALchange"><code class="code"><span class="constructor">Time_Zone</span>.change</code></a>), each time consequently changes. + If you want to express a time in another time zone (and do not affect others times), use the <code class="code">convert</code> function.<br> <hr width="100%"> <pre><span class="keyword">module type</span> <a href="Time_sig.Second.html">Second</a> = <code class="code"><span class="keyword">sig</span></code> <a href="Time_sig.Second.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info"> diff --git a/doc/Utils.Comparable.html b/doc/Utils.Comparable.html index 537a7a1..1d20efd 100644 --- a/doc/Utils.Comparable.html +++ b/doc/Utils.Comparable.html @@ -30,7 +30,7 @@ </div> <center><h1>Module type <a href="type_Utils.Comparable.html">Utils.Comparable</a></h1></center> <br> -<pre><span class="keyword">module type</span> Comparable = <code class="code"><span class="keyword">sig</span></code> <a href="Utils.Comparable.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Interface for comparable and hashable types. +<pre><span class="keyword">module type</span> Comparable = <code class="code"><span class="keyword">sig</span></code> <a href="Utils.Comparable.html">..</a> <code class="code"><span class="keyword">end</span></code></pre>Interface for comparable and hashable types. Modules implementing this interface can be an argument of <code class="code"><span class="constructor">Map</span>.<span class="constructor">Make</span></code>, <code class="code"><span class="constructor">Set</span>.<span class="constructor">Make</span></code> or <code class="code"><span class="constructor">Hashtbl</span>.<span class="constructor">Make</span></code>.<br> <b>Since</b> 2.0<br> @@ -41,7 +41,7 @@ Equality over <code class="code">t</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type"><a href="Utils.Comparable.html#TYPEt">t</a> -> <a href="Utils.Comparable.html#TYPEt">t</a> -> int</code></pre><div class="info"> -Comparison over <code class="code">t</code>. +Comparison over <code class="code">t</code>. <code class="code">compare x y</code> returns <code class="code">0</code> iff <code class="code">equal x y = 0</code>. If <code class="code">x</code> and <code class="code">y</code> are not equal, it returns a negative integer iff <code class="code">x</code> is lesser than <code class="code">y</code> and a positive integer otherwise.<br> diff --git a/doc/Utils.Float.html b/doc/Utils.Float.html index 22c9e84..2a77da3 100644 --- a/doc/Utils.Float.html +++ b/doc/Utils.Float.html @@ -37,7 +37,7 @@ <hr width="100%"> <pre><span class="keyword">include</span> <a href="Utils.Comparable.html">Utils.Comparable</a></pre> <pre><span class="keyword">val</span> <a name="VALset_precision"></a>set_precision : <code class="type">float -> unit</code></pre><div class="info"> -Set the precision of <code class="code">equal</code> and <code class="code">compare</code> for float. +Set the precision of <code class="code">equal</code> and <code class="code">compare</code> for float. If the precision is <code class="code">p</code>, then the floats <code class="code">x</code> and <code class="code">y</code> are equal iff <code class="code">abs(x-y) < p</code>. By default, the precision is <code class="code">1e-3</code> (that is one millisecond if floats represents seconds).<br> diff --git a/doc/Utils.Int.html b/doc/Utils.Int.html index 8e86383..74992f2 100644 --- a/doc/Utils.Int.html +++ b/doc/Utils.Int.html @@ -41,7 +41,7 @@ Equality over <code class="code">t</code>.<br> </div> <pre><span class="keyword">val</span> <a name="VALcompare"></a>compare : <code class="type"><a href="Utils.Comparable.html#TYPEt">t</a> -> <a href="Utils.Comparable.html#TYPEt">t</a> -> int</code></pre><div class="info"> -Comparison over <code class="code">t</code>. +Comparison over <code class="code">t</code>. <code class="code">compare x y</code> returns <code class="code">0</code> iff <code class="code">equal x y = 0</code>. If <code class="code">x</code> and <code class="code">y</code> are not equal, it returns a negative integer iff <code class="code">x</code> is lesser than <code class="code">y</code> and a positive integer otherwise.<br> diff --git a/doc/index_exceptions.html b/doc/index_exceptions.html index 7a85509..3011ccd 100644 --- a/doc/index_exceptions.html +++ b/doc/index_exceptions.html @@ -45,7 +45,7 @@ Raised when a date is outside the Julian period. <tr><td align="left"><br>U</td></tr> <tr><td><a href="Date_sig.S.html#EXCEPTIONUndefined">Undefined</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> -Raised when a date belongs to +Raised when a date belongs to <code class="code">[<span class="constructor">October</span> 5th, 1582; <span class="constructor">October</span> 14th, 1582]</code>. </div> </td></tr> diff --git a/doc/index_types.html b/doc/index_types.html index 410250e..c13db6b 100644 --- a/doc/index_types.html +++ b/doc/index_types.html @@ -27,6 +27,13 @@ <center><h1>Index of types</h1></center> <table> <tr><td align="left"><br>D</td></tr> +<tr><td><a href="Date_sig.S.html#TYPEdate">date</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> +<td><div class="info"> +Type of a date, without specifying any precision level. +</div> +</td></tr> +<tr><td><a href="Period.html#TYPEdate_field">date_field</a> [<a href="Period.html">Period</a>]</td> +<td></td></tr> <tr><td><a href="Calendar_sig.S.html#TYPEday">day</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td></td></tr> <tr><td><a href="Date_sig.S.html#TYPEday">day</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> @@ -58,6 +65,13 @@ The different fields of a time. Months of the year. </div> </td></tr> +<tr><td align="left"><br>P</td></tr> +<tr><td><a href="Date_sig.S.Period.html#TYPEp">p</a> [<a href="Date_sig.S.Period.html">Date_sig.S.Period</a>]</td> +<td></td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#TYPEperiod">period</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td></td></tr> +<tr><td><a href="Period.S.html#TYPEperiod">period</a> [<a href="Period.S.html">Period.S</a>]</td> +<td></td></tr> <tr><td align="left"><br>S</td></tr> <tr><td><a href="Calendar_sig.S.html#TYPEsecond">second</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td></td></tr> @@ -72,11 +86,13 @@ Type of a second. Generic type of a printer. </div> </td></tr> -<tr><td><a href="Calendar_sig.S.html#TYPEt">t</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> +<tr><td><a href="Calendar_sig.S.Period.html#TYPEt">t</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> <td><div class="info"> -Type of a date refined with a time, so called a calendar. +Type of a period. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.html#TYPEt">t</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> +<td></td></tr> <tr><td><a href="Date_sig.S.html#TYPEt">t</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> Type of a date. diff --git a/doc/index_values.html b/doc/index_values.html index 074e534..2e89016 100644 --- a/doc/index_values.html +++ b/doc/index_values.html @@ -27,6 +27,11 @@ <center><h1>Index of values</h1></center> <table> <tr><td align="left"><br>A</td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALadd">add</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Addition of periods. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALadd">add</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> </div> @@ -72,6 +77,11 @@ Century of a year. Change the current time zone by another one. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALcompare">compare</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Comparison function between two periods. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALcompare">compare</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> Comparison function between two calendars. @@ -195,7 +205,7 @@ Division. </td></tr> <tr><td><a href="Printer.S.html#VALdprint">dprint</a> [<a href="Printer.S.html">Printer.S</a>]</td> <td><div class="info"> -Same as <code class="code">print d</code> where <code class="code">d</code> is the default format +Same as <code class="code">print d</code> where <code class="code">d</code> is the default format (see the printer implementations). </div> </td></tr> @@ -220,6 +230,11 @@ Easter Monday. Easter Saturday. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALempty">empty</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +The empty period. +</div> +</td></tr> <tr><td><a href="Period.S.html#VALempty">empty</a> [<a href="Period.S.html">Period.S</a>]</td> <td><div class="info"> The empty period. @@ -230,6 +245,11 @@ The empty period. Epact. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALequal">equal</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Equality function between two periods. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALequal">equal</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> Equality function between two calendars. @@ -389,6 +409,11 @@ Golden number. </div> </td></tr> <tr><td align="left"><br>H</td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALhash">hash</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Hash function for periods. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALhash">hash</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> Hash function for calendars. @@ -459,7 +484,7 @@ Convert a month to an integer respecting ISO-8601. </td></tr> <tr><td><a href="Time_sig.S.html#VALis_am">is_am</a> [<a href="Time_sig.S.html">Time_sig.S</a>]</td> <td><div class="info"> -Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; +Return <code class="code"><span class="keyword">true</span></code> is the time is after midday in the current time zone; <code class="code"><span class="keyword">false</span></code> otherwise. </div> </td></tr> @@ -558,7 +583,7 @@ Labelled version of <code class="code">make</code>. <tr><td align="left"><br>M</td></tr> <tr><td><a href="Calendar_sig.S.Period.html#VALmake">make</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> <td><div class="info"> -<code class="code">make year month day hour minute second</code> makes a period of the +<code class="code">make year month day hour minute second</code> makes a period of the specified length. </div> </td></tr> @@ -588,6 +613,17 @@ Labelled version of <code class="code">make</code>. <code class="code">make hour minute second</code> makes the time hour-minute-second. </div> </td></tr> +<tr><td><a href="Date_sig.S.html#VALmake_year">make_year</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> +<td><div class="info"> +<code class="code">make_year y</code> makes a date only represented by its year <code class="code">y</code>. +</div> +</td></tr> +<tr><td><a href="Date_sig.S.html#VALmake_year_month">make_year_month</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> +<td><div class="info"> +<code class="code">make_year_month y m</code> makes a date only represented by its year <code class="code">y</code> and + its month <code class="code">m</code>. +</div> +</td></tr> <tr><td><a href="Date_sig.S.html#VALmardi_gras">mardi_gras</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> Mardi Gras. @@ -672,8 +708,8 @@ Multiplication. </td></tr> <tr><td><a href="Date_sig.S.Period.html#VALnb_days">nb_days</a> [<a href="Date_sig.S.Period.html">Date_sig.S.Period</a>]</td> <td><div class="info"> -Number of days in a period. -</div> +<font color="#CCCCCC">Number of days in a period. +</font></div> </td></tr> <tr><td><a href="Calendar_sig.S.html#VALnext">next</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> @@ -719,6 +755,11 @@ The current time based on <code class="code"><span class="constructor">Time_Zone the computation. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALopp">opp</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Opposite of a period. +</div> +</td></tr> <tr><td><a href="Period.S.html#VALopp">opp</a> [<a href="Period.S.html">Period.S</a>]</td> <td><div class="info"> Opposite of a period. @@ -730,13 +771,22 @@ Opposite of a period. Palm Sunday. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.html#VALprecise_sub">precise_sub</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> +<td><div class="info"> +</div> +</td></tr> +<tr><td><a href="Date_sig.S.html#VALprecise_sub">precise_sub</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> +<td><div class="info"> +<code class="code">precise_sub d1 d2</code> returns the period between <code class="code">d1</code> and <code class="code">d2</code>. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALprev">prev</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> </div> </td></tr> <tr><td><a href="Date_sig.S.html#VALprev">prev</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> -<code class="code">prev d f</code> returns the date corresponding to the previous specified +<code class="code">prev d f</code> returns the date corresponding to the previous specified field. </div> </td></tr> @@ -772,6 +822,16 @@ Round a float to the nearest integer. </div> </td></tr> <tr><td align="left"><br>S</td></tr> +<tr><td><a href="Date_sig.S.Period.html#VALsafe_nb_days">safe_nb_days</a> [<a href="Date_sig.S.Period.html">Date_sig.S.Period</a>]</td> +<td><div class="info"> +Equivalent to <a href="Date_sig.S.Period.html#VALnb_days"><code class="code"><span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.nb_days</code></a> but never raises any exception. +</div> +</td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALsafe_to_time">safe_to_time</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Equivalent to <a href="Calendar_sig.S.Period.html#VALto_time"><code class="code"><span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.to_time</code></a> but never raises any exception. +</div> +</td></tr> <tr><td><a href="Date_sig.S.html#VALsame_calendar">same_calendar</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> Return <code class="code"><span class="keyword">true</span></code> if two years have the same calendar; <code class="code"><span class="keyword">false</span></code> @@ -814,7 +874,7 @@ Set the regular expression used to recognize words in </td></tr> <tr><td><a href="Printer.html#VALshort_name_of_month">short_name_of_month</a> [<a href="Printer.html">Printer</a>]</td> <td><div class="info"> -<code class="code">short_name_of_month d</code> returns the 3 first characters of +<code class="code">short_name_of_month d</code> returns the 3 first characters of <code class="code">name_of_month d</code>. </div> </td></tr> @@ -829,6 +889,11 @@ Solar number. <code class="code">format</code>. </div> </td></tr> +<tr><td><a href="Calendar_sig.S.Period.html#VALsub">sub</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> +<td><div class="info"> +Substraction of periods. +</div> +</td></tr> <tr><td><a href="Calendar_sig.S.html#VALsub">sub</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> </div> @@ -875,7 +940,7 @@ Inverse of <code class="code">from_float</code>. </td></tr> <tr><td><a href="Time_sig.S.html#VALto_gmt">to_gmt</a> [<a href="Time_sig.S.html">Time_sig.S</a>]</td> <td><div class="info"> -<code class="code">to_gmt t</code> is equivalent to +<code class="code">to_gmt t</code> is equivalent to <code class="code">convert t (<span class="constructor">Time_Zone</span>.current ()) <span class="constructor">Time_Zone</span>.<span class="constructor">GMT</span></code>. </div> </td></tr> @@ -941,8 +1006,8 @@ Same as <code class="code">sprint d</code> where <code class="code">d</code> is </td></tr> <tr><td><a href="Calendar_sig.S.Period.html#VALto_time">to_time</a> [<a href="Calendar_sig.S.Period.html">Calendar_sig.S.Period</a>]</td> <td><div class="info"> -Convert a calendar period to a date period. -</div> +<font color="#CCCCCC">Convert a calendar period to a date period. +</font></div> </td></tr> <tr><td><a href="Calendar_sig.S.html#VALto_time">to_time</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> @@ -951,13 +1016,13 @@ Convert a calendar to a time. </td></tr> <tr><td><a href="Calendar_sig.S.html#VALto_unixfloat">to_unixfloat</a> [<a href="Calendar_sig.S.html">Calendar_sig.S</a>]</td> <td><div class="info"> -Convert a calendar to a float such than +Convert a calendar to a float such than <code class="code">to_unixfloat (make 1970 1 1 0 0 0)</code> returns <code class="code">0.0</code> at UTC. </div> </td></tr> <tr><td><a href="Date_sig.S.html#VALto_unixfloat">to_unixfloat</a> [<a href="Date_sig.S.html">Date_sig.S</a>]</td> <td><div class="info"> -Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> +Convert a date to a float such than <code class="code">to_unixfloat (make 1970 1 1)</code> returns <code class="code">0.0</code>. </div> </td></tr> diff --git a/doc/type_Calendar.Precise.html b/doc/type_Calendar.Precise.html index e2faf1a..3d53536 100644 --- a/doc/type_Calendar.Precise.html +++ b/doc/type_Calendar.Precise.html @@ -24,10 +24,11 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -44,27 +45,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -81,29 +83,41 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -167,32 +181,46 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -252,36 +280,51 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date : ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Calendar.html b/doc/type_Calendar.html index 477e129..73dda6b 100644 --- a/doc/type_Calendar.html +++ b/doc/type_Calendar.html @@ -24,10 +24,11 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -44,27 +45,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -81,29 +83,41 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -167,32 +181,46 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -252,44 +280,60 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date : ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Precise</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -306,27 +350,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -343,29 +388,43 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -429,33 +488,51 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -516,37 +593,55 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> diff --git a/doc/type_Calendar_builder.Make.html b/doc/type_Calendar_builder.Make.html index b243f2b..dd746ac 100644 --- a/doc/type_Calendar_builder.Make.html +++ b/doc/type_Calendar_builder.Make.html @@ -26,10 +26,11 @@ <code class="code"><span class="keyword">functor</span> (<span class="constructor">D</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">functor</span> (<span class="constructor">T</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">D</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">D</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">D</span>.month =<br> @@ -46,27 +47,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -83,29 +85,43 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">D</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -169,33 +185,51 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">T</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">T</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -256,37 +290,55 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Calendar_builder.Make_Precise.html b/doc/type_Calendar_builder.Make_Precise.html index cd34064..9db6826 100644 --- a/doc/type_Calendar_builder.Make_Precise.html +++ b/doc/type_Calendar_builder.Make_Precise.html @@ -26,10 +26,11 @@ <code class="code"><span class="keyword">functor</span> (<span class="constructor">D</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">functor</span> (<span class="constructor">T</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">D</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">D</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">D</span>.month =<br> @@ -46,27 +47,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -83,29 +85,43 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">D</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -169,33 +185,51 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">T</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">T</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -256,37 +290,55 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Calendar_builder.html b/doc/type_Calendar_builder.html index 0f1240d..2339793 100644 --- a/doc/type_Calendar_builder.html +++ b/doc/type_Calendar_builder.html @@ -28,10 +28,11 @@ <span class="keyword">functor</span> (<span class="constructor">D</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">functor</span> (<span class="constructor">T</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">D</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">D</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">D</span>.month =<br> @@ -48,27 +49,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -85,30 +87,48 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">D</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -173,33 +193,52 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">T</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">T</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -261,37 +300,61 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second :<br> + second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub :<br> + t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> @@ -299,10 +362,11 @@ <span class="keyword">functor</span> (<span class="constructor">D</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">functor</span> (<span class="constructor">T</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>) <span class="keywordsign">-></span><br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">D</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">D</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">D</span>.month =<br> @@ -319,27 +383,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -356,30 +421,48 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">D</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">D</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -444,33 +527,52 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">T</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">T</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -532,37 +634,61 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second :<br> + second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub :<br> + t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> diff --git a/doc/type_Calendar_sig.S.Period.html b/doc/type_Calendar_sig.S.Period.html index 202080e..34ec8b5 100644 --- a/doc/type_Calendar_sig.S.Period.html +++ b/doc/type_Calendar_sig.S.Period.html @@ -24,34 +24,68 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make :<br> int <span class="keywordsign">-></span><br> - int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + int <span class="keywordsign">-></span><br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span><br> - ?minute:int <span class="keywordsign">-></span> ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_date : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> month :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> week :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> day :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> hour :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> minute :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> second :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Calendar_sig.S.html b/doc/type_Calendar_sig.S.html index a2085b9..bb55fe2 100644 --- a/doc/type_Calendar_sig.S.html +++ b/doc/type_Calendar_sig.S.html @@ -24,9 +24,9 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span><br> <span class="keyword">module</span> <span class="constructor">Time</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -91,41 +91,90 @@ <span class="keyword">val</span> to_time : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make :<br> int <span class="keywordsign">-></span><br> - int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + int <span class="keywordsign">-></span><br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span><br> ?minute:int <span class="keywordsign">-></span><br> - ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_date : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year :<br> + int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> month :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> week :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> day :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> hour :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> minute :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> second :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> add :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> sub :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> next : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> prev : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Calendar_sig.html b/doc/type_Calendar_sig.html index 56235ff..775d74f 100644 --- a/doc/type_Calendar_sig.html +++ b/doc/type_Calendar_sig.html @@ -26,9 +26,9 @@ <code class="code"><span class="keyword">sig</span><br> <span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> : <span class="constructor">Date_sig</span>.<span class="constructor">S</span><br> <span class="keyword">module</span> <span class="constructor">Time</span> : <span class="constructor">Time_sig</span>.<span class="constructor">S</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -95,46 +95,98 @@ <span class="keyword">val</span> to_time : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a)<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make :<br> int <span class="keywordsign">-></span><br> int <span class="keywordsign">-></span><br> - int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + int <span class="keywordsign">-></span><br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span><br> ?minute:int <span class="keywordsign">-></span><br> - ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_date : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + ?second:<span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> month :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> week :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> day :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> hour :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> minute :<br> + int <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> second :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">val</span> ymds :<br> - <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + int * int * int * <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.second<br> <span class="keyword">end</span><br> <span class="keyword">val</span> add :<br> - <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> sub :<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> <span class="keyword">val</span> rem :<br> - <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span><br> + <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> next : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> prev : <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Calendar_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">end</span><br> diff --git a/doc/type_Date.html b/doc/type_Date.html index ecedf32..dfc932f 100644 --- a/doc/type_Date.html +++ b/doc/type_Date.html @@ -24,7 +24,9 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Jan</span><br> @@ -40,27 +42,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -77,29 +80,40 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> diff --git a/doc/type_Date_sig.S.Period.html b/doc/type_Date_sig.S.Period.html index 750eb42..8d39441 100644 --- a/doc/type_Date_sig.S.Period.html +++ b/doc/type_Date_sig.S.Period.html @@ -24,21 +24,26 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Date_sig.S.html b/doc/type_Date_sig.S.html index 3a78b7b..4a4d4e2 100644 --- a/doc/type_Date_sig.S.html +++ b/doc/type_Date_sig.S.html @@ -24,7 +24,9 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">type</span> day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Jan</span><br> @@ -40,28 +42,35 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> lmake :<br> year:<span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_day_of_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> days_in_month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.day<br> <span class="keyword">val</span> day_of_month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> - <span class="keyword">val</span> year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year<br> + <span class="keyword">val</span> month :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> + <span class="keyword">val</span> year : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year<br> <span class="keyword">val</span> to_jd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> @@ -79,29 +88,49 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> next : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> prev : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> next :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> prev :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">val</span> is_leap_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:<span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int<br> diff --git a/doc/type_Date_sig.html b/doc/type_Date_sig.html index 3c42275..2311890 100644 --- a/doc/type_Date_sig.html +++ b/doc/type_Date_sig.html @@ -26,7 +26,9 @@ <code class="code"><span class="keyword">sig</span><br> <span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">type</span> day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Jan</span><br> @@ -42,29 +44,37 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> lmake :<br> year:<span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> from_day_of_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> days_in_month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.day<br> <span class="keyword">val</span> day_of_month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> - <span class="keyword">val</span> year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year<br> + <span class="keyword">val</span> month :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> + <span class="keyword">val</span> year :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year<br> <span class="keyword">val</span> to_jd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> @@ -83,30 +93,53 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> next : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> prev : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + [< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> next :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> + <span class="keyword">val</span> prev :<br> + ([< <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.date<br> <span class="keyword">val</span> is_leap_year : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:<span class="constructor">Date_sig</span>.<span class="constructor">S</span>.month <span class="keywordsign">-></span> <span class="constructor">Date_sig</span>.<span class="constructor">S</span>.year <span class="keywordsign">-></span> int<br> diff --git a/doc/type_Fcalendar.Precise.html b/doc/type_Fcalendar.Precise.html index c31c167..5783696 100644 --- a/doc/type_Fcalendar.Precise.html +++ b/doc/type_Fcalendar.Precise.html @@ -24,10 +24,11 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -44,27 +45,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -81,29 +83,41 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -167,32 +181,46 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -252,36 +280,51 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date : ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Fcalendar.html b/doc/type_Fcalendar.html index 0a85cef..bcc26dc 100644 --- a/doc/type_Fcalendar.html +++ b/doc/type_Fcalendar.html @@ -24,10 +24,11 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -44,27 +45,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -81,29 +83,41 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -167,32 +181,46 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -252,44 +280,60 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date : ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Precise</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> <span class="keyword">module</span> <span class="constructor">Date</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.t<br> + <span class="keyword">type</span> field = <span class="constructor">Period</span>.date_field<br> + <span class="keyword">type</span> -<span class="keywordsign">'</span>a date = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.date <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = field date<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -306,27 +350,28 @@ <span class="keywordsign">|</span> <span class="constructor">Nov</span><br> <span class="keywordsign">|</span> <span class="constructor">Dec</span><br> <span class="keyword">type</span> year = int<br> - <span class="keyword">type</span> field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">exception</span> <span class="constructor">Out_of_bounds</span><br> <span class="keyword">exception</span> <span class="constructor">Undefined</span><br> <span class="keyword">val</span> make : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : year:year <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> make_year : int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> + <span class="keyword">val</span> make_year_month : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> [< <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date<br> <span class="keyword">val</span> today : unit <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_jd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_mjd : int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> from_day_of_year : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> days_in_month : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> days_in_month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_week : t <span class="keywordsign">-></span> day<br> <span class="keyword">val</span> day_of_month : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> day_of_year : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> week : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> month : t <span class="keywordsign">-></span> month<br> - <span class="keyword">val</span> year : t <span class="keywordsign">-></span> year<br> + <span class="keyword">val</span> month : [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> ] date <span class="keywordsign">-></span> month<br> + <span class="keyword">val</span> year : [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] date <span class="keywordsign">-></span> year<br> <span class="keyword">val</span> to_jd : t <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> to_mjd : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> equal : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare : [< field ] date <span class="keywordsign">-></span> [< field ] date <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< field ] date <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> is_valid_date : year <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_leap_day : t <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> is_gregorian : t <span class="keywordsign">-></span> bool<br> @@ -343,29 +388,43 @@ <span class="keyword">val</span> month_of_int : int <span class="keywordsign">-></span> month<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a p = <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a p <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake : ?year:int <span class="keywordsign">-></span> ?month:int <span class="keywordsign">-></span> ?day:int <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> nb_days : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> ymd : t <span class="keywordsign">-></span> int * int * int<br> + <span class="keyword">val</span> nb_days : [< field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> safe_nb_days : [< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> ymd : [< field ] period <span class="keywordsign">-></span> int * int * int<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> sub :<br> + ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> [< field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> next : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> + <span class="keyword">val</span> prev : ([< field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) date <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="keywordsign">-></span> <span class="keywordsign">'</span>a date<br> <span class="keyword">val</span> is_leap_year : year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> same_calendar : year <span class="keywordsign">-></span> year <span class="keywordsign">-></span> bool<br> <span class="keyword">val</span> days_in_year : ?month:month <span class="keywordsign">-></span> year <span class="keywordsign">-></span> int<br> @@ -429,33 +488,51 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t = <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period = <span class="keywordsign">'</span>a <span class="constructor">Ftime</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> - ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> + <span class="keyword">type</span> t<br> <span class="keyword">type</span> day = <span class="constructor">Date</span>.day = <span class="constructor">Sun</span> <span class="keywordsign">|</span> <span class="constructor">Mon</span> <span class="keywordsign">|</span> <span class="constructor">Tue</span> <span class="keywordsign">|</span> <span class="constructor">Wed</span> <span class="keywordsign">|</span> <span class="constructor">Thu</span> <span class="keywordsign">|</span> <span class="constructor">Fri</span> <span class="keywordsign">|</span> <span class="constructor">Sat</span><br> <span class="keyword">type</span> month =<br> <span class="constructor">Date</span>.month =<br> @@ -516,37 +593,55 @@ <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> lmake :<br> ?year:int <span class="keywordsign">-></span><br> ?month:int <span class="keywordsign">-></span><br> ?day:int <span class="keywordsign">-></span><br> ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> year : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> month : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> week : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> day : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_date : <span class="constructor">Date</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> from_time : <span class="constructor">Time</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_date : t <span class="keywordsign">-></span> <span class="constructor">Date</span>.<span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> year : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> month : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ] period<br> + <span class="keyword">val</span> week : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> day : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] period<br> + <span class="keyword">val</span> from_date :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Date</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> from_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Time</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> to_date :<br> + ([< <span class="constructor">Date</span>.field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Date</span>.<span class="constructor">Period</span>.period<br> <span class="keyword">exception</span> <span class="constructor">Not_computable</span><br> - <span class="keyword">val</span> to_time : t <span class="keywordsign">-></span> <span class="constructor">Time</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> ymds : t <span class="keywordsign">-></span> int * int * int * second<br> + <span class="keyword">val</span> to_time :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> safe_to_time :<br> + ([< <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Time</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> ymds :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int * int * int * second<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field > <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">`</span><span class="constructor">Week</span> ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> precise_sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span><br> diff --git a/doc/type_Ftime.html b/doc/type_Ftime.html index 0f44dcb..7dd794b 100644 --- a/doc/type_Ftime.html +++ b/doc/type_Ftime.html @@ -60,29 +60,40 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Period.S.html b/doc/type_Period.S.html index 83b4c20..dc232b2 100644 --- a/doc/type_Period.S.html +++ b/doc/type_Period.S.html @@ -24,12 +24,22 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> add : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> opp : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> equal : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> int<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Period.html b/doc/type_Period.html index 08b7c88..cf5f6ae 100644 --- a/doc/type_Period.html +++ b/doc/type_Period.html @@ -24,15 +24,26 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> + <span class="keyword">type</span> date_field = [ <span class="keywordsign">`</span><span class="constructor">Day</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Month</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Week</span> <span class="keywordsign">|</span> <span class="keywordsign">`</span><span class="constructor">Year</span> ]<br> <span class="keyword">module</span> <span class="keyword">type</span> <span class="constructor">S</span> =<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> add : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> opp : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> equal : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : <span class="constructor">Period</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> int<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> opp :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a <span class="constructor">Period</span>.<span class="constructor">S</span>.period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.<span class="constructor">S</span>.period <span class="keywordsign">-></span> int<br> <span class="keyword">end</span><br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Time.html b/doc/type_Time.html index 731d28e..4cb5109 100644 --- a/doc/type_Time.html +++ b/doc/type_Time.html @@ -60,29 +60,40 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> mul : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> div : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> lmake : ?hour:int <span class="keywordsign">-></span> ?minute:int <span class="keywordsign">-></span> ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> second : second <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> to_seconds : t <span class="keywordsign">-></span> second<br> - <span class="keyword">val</span> to_minutes : t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : t <span class="keywordsign">-></span> float<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> lmake :<br> + ?hour:int <span class="keywordsign">-></span><br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> <span class="constructor">Period</span>.t <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> add : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> + <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem : t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Period</span>.period <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> next : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">val</span> prev : t <span class="keywordsign">-></span> field <span class="keywordsign">-></span> t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Time_sig.S.Period.html b/doc/type_Time_sig.S.Period.html index b5683e2..ae0badb 100644 --- a/doc/type_Time_sig.S.Period.html +++ b/doc/type_Time_sig.S.Period.html @@ -24,25 +24,29 @@ </head> <body> <code class="code"><span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> mul : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> div : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> mul : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> ?hour:int <span class="keywordsign">-></span><br> - ?minute:int <span class="keywordsign">-></span> ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_seconds : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> to_minutes : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Time_sig.S.html b/doc/type_Time_sig.S.html index 73ce3ac..4ae96eb 100644 --- a/doc/type_Time_sig.S.html +++ b/doc/type_Time_sig.S.html @@ -62,31 +62,47 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> mul : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> div : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> ?hour:int <span class="keywordsign">-></span><br> - ?minute:int <span class="keywordsign">-></span> ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_seconds : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> to_minutes : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> add :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> sub :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> next : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> prev : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">end</span></code></body></html>
\ No newline at end of file diff --git a/doc/type_Time_sig.html b/doc/type_Time_sig.html index 4b022d7..811deda 100644 --- a/doc/type_Time_sig.html +++ b/doc/type_Time_sig.html @@ -73,31 +73,49 @@ <span class="keyword">val</span> from_hours : float <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">module</span> <span class="constructor">Period</span> :<br> <span class="keyword">sig</span><br> - <span class="keyword">type</span> t<br> - <span class="keyword">val</span> empty : t<br> - <span class="keyword">val</span> add : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> sub : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> opp : t <span class="keywordsign">-></span> t<br> - <span class="keyword">val</span> equal : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> bool<br> - <span class="keyword">val</span> compare : t <span class="keywordsign">-></span> t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> hash : t <span class="keywordsign">-></span> int<br> - <span class="keyword">val</span> length : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> mul : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> div : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> make : int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">type</span> +<span class="keywordsign">'</span>a period <span class="keyword">constraint</span> <span class="keywordsign">'</span>a = [< <span class="constructor">Period</span>.date_field ]<br> + <span class="keyword">type</span> t = <span class="constructor">Period</span>.date_field period<br> + <span class="keyword">val</span> empty : [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> add :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> sub :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> opp : ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> equal :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> bool<br> + <span class="keyword">val</span> compare :<br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> hash : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> int<br> + <span class="keyword">val</span> length : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> mul :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> div :<br> + ([< <span class="constructor">Period</span>.date_field ] <span class="keyword">as</span> <span class="keywordsign">'</span>a) period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period <span class="keywordsign">-></span> <span class="keywordsign">'</span>a period<br> + <span class="keyword">val</span> make :<br> + int <span class="keywordsign">-></span> int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> <span class="keyword">val</span> lmake :<br> ?hour:int <span class="keywordsign">-></span><br> - ?minute:int <span class="keywordsign">-></span> ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> unit <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> to_seconds : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> - <span class="keyword">val</span> to_minutes : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> - <span class="keyword">val</span> to_hours : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> float<br> + ?minute:int <span class="keywordsign">-></span><br> + ?second:<span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span><br> + unit <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> hour : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> minute : int <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> second : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] period<br> + <span class="keyword">val</span> to_seconds : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.second<br> + <span class="keyword">val</span> to_minutes : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> + <span class="keyword">val</span> to_hours : [< <span class="constructor">Period</span>.date_field ] period <span class="keywordsign">-></span> float<br> <span class="keyword">end</span><br> - <span class="keyword">val</span> add : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> - <span class="keyword">val</span> sub : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t<br> - <span class="keyword">val</span> rem : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> add :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> + <span class="keyword">val</span> sub :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period<br> + <span class="keyword">val</span> rem :<br> + <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span><br> + [< <span class="constructor">Period</span>.date_field ] <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.<span class="constructor">Period</span>.period <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> next : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">val</span> prev : <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.field <span class="keywordsign">-></span> <span class="constructor">Time_sig</span>.<span class="constructor">S</span>.t<br> <span class="keyword">end</span><br> diff --git a/src/.cvsignore b/src/.cvsignore deleted file mode 100644 index ec7297c..0000000 --- a/src/.cvsignore +++ /dev/null @@ -1 +0,0 @@ -version.ml diff --git a/src/calendar.ml b/src/calendar.ml index f8a03b1..4d3b01e 100644 --- a/src/calendar.ml +++ b/src/calendar.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: calendar.ml,v 1.25 2008/02/05 15:36:21 signoles Exp $ i*) - include Calendar_builder.Make(Date)(Time) module Precise = Calendar_builder.Make_Precise(Date)(Time) diff --git a/src/calendar.mli b/src/calendar.mli index eafacb4..8ee75f8 100644 --- a/src/calendar.mli +++ b/src/calendar.mli @@ -2,32 +2,32 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: calendar.mli,v 1.25 2008/02/05 15:36:21 signoles Exp $ i*) - (** Calendar implementation in which seconds are integer. This module uses float. Then results may be unprecise, especially - comparison of calendars which differ with few seconds. + comparison of calendars which differ with few seconds. In this case, consider to use module [Precise]. *) include Calendar_sig.S with module Date = Date and module Time = Time -(** More precise implementation of calendar in which seconds are integer. +(** More precise implementation of calendar in which seconds are integer. @since 2.0 *) module Precise: Calendar_sig.S with module Date = Date and module Time = Time diff --git a/src/calendar_builder.ml b/src/calendar_builder.ml index 2f06918..0d8d580 100644 --- a/src/calendar_builder.ml +++ b/src/calendar_builder.ml @@ -2,29 +2,29 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: calendar_builder.ml,v 1.3 2008/02/05 15:36:21 signoles Exp $ i*) - (*S Introduction. A calendar is representing by its (exact) Julian Day -. 0.5. - This gap of 0.5 is because the Julian period begins - January first, 4713 BC at MIDDAY (and then, this Julian day is 0.0). + This gap of 0.5 is because the Julian period begins + January first, 4713 BC at MIDDAY (and then, this Julian day is 0.0). But, for implementation facilities, the Julian day 0.0 is coded as January first, 4713 BC at MIDNIGHT. *) @@ -36,12 +36,12 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct module Date = D module Time = T - + type day = D.day = Sun | Mon | Tue | Wed | Thu | Fri | Sat type month = D.month = Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec - + type year = int type second = T.second @@ -49,7 +49,7 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct type field = [ D.field | T.field ] (*S Conversions. *) - + let convert x t1 t2 = x +. float (Time_Zone.gap t1 t2) /. 24. let to_gmt x = convert x (Time_Zone.current ()) Time_Zone.UTC @@ -61,8 +61,8 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let to_date x = D.from_jd (int_of_float (from_gmt x +. 0.5)) (* Return the fractional part of [x] as a time. *) - let to_time x = - let t, _ = modf (from_gmt x +. 0.5) in + let to_time x = + let t, _ = modf (from_gmt x +. 0.5) in let i = t *. 86400. in assert (i < 86400.); T.from_seconds (T.Second.from_float i) @@ -71,12 +71,12 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let is_valid x = x >= 0. && x < 2914695. - let create d t = - to_gmt - (float (D.to_jd d) + let create d t = + to_gmt + (float (D.to_jd d) +. T.Second.to_float (T.to_seconds t) /. 86400.) -. 0.5 - let make y m d h mn s = + let make y m d h mn s = let x = create (D.make y m d) (T.make h mn s) in if is_valid x then x else raise D.Out_of_bounds @@ -84,16 +84,16 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct ?(second=T.Second.from_int 0) () = make year month day hour minute second - let now () = + let now () = let now = Unix.gettimeofday () in let gmnow = Unix.gmtime now in let frac, _ = modf now in - from_gmt (make - (gmnow.Unix.tm_year + 1900) - (gmnow.Unix.tm_mon + 1) - gmnow.Unix.tm_mday - gmnow.Unix.tm_hour - gmnow.Unix.tm_min + from_gmt (make + (gmnow.Unix.tm_year + 1900) + (gmnow.Unix.tm_mon + 1) + gmnow.Unix.tm_mday + gmnow.Unix.tm_hour + gmnow.Unix.tm_min (T.Second.from_float (float gmnow.Unix.tm_sec +. frac))) let from_jd x = to_gmt x @@ -127,9 +127,9 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let to_unixtm x = let tm = D.to_unixtm (to_date x) and t = to_time x in - { tm with - Unix.tm_sec = T.Second.to_int (T.second t); - Unix.tm_min = T.minute t; + { tm with + Unix.tm_sec = T.Second.to_int (T.second t); + Unix.tm_min = T.minute t; Unix.tm_hour = T.hour t } let jan_1_1970 = 2440587.5 @@ -146,10 +146,14 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let is_am x = T.is_am (to_time x) (*S Period. *) - + module Period = struct - type t = { d : D.Period.t; t : T.Period.t } + type +'a p = { d : 'a D.Period.period; t : 'a T.Period.period } + constraint 'a = [< Period.date_field ] + + type +'a period = 'a p + type t = Period.date_field period let split x = let rec aux s = @@ -157,7 +161,7 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct in let s = T.Second.to_float (T.Period.length x.t) in let d, s = - if s >= 0. then aux s + if s >= 0. then aux s else let d, s = aux (-. s) in - (d + 1), -. s +. 86400. in assert (s >= 0. && s < 86400.); @@ -169,10 +173,10 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let empty = { d = D.Period.empty; t = T.Period.empty } - let make y m d h mn s = + let make y m d h mn s = normalize { d = D.Period.make y m d; t = T.Period.make h mn s } - let lmake ?(year=0) ?(month=0) ?(day=0) ?(hour=0) ?(minute=0) + let lmake ?(year=0) ?(month=0) ?(day=0) ?(hour=0) ?(minute=0) ?(second=T.Second.from_int 0) () = make year month day hour minute second @@ -185,15 +189,15 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct let minute x = normalize { empty with t = T.Period.minute x } let second x = normalize { empty with t = T.Period.second x } - let add x y = + let add x y = normalize { d = D.Period.add x.d y.d; t = T.Period.add x.t y.t } - let sub x y = + let sub x y = normalize { d = D.Period.sub x.d y.d; t = T.Period.sub x.t y.t } let opp x = normalize { d = D.Period.opp x.d; t = T.Period.opp x.t } - let compare x y = + let compare x y = let n = D.Period.compare x.d y.d in if n = 0 then T.Period.compare x.t y.t else n @@ -207,8 +211,9 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct exception Not_computable = D.Period.Not_computable - let to_time x = - T.Period.add (T.Period.hour (D.Period.nb_days x.d * 24)) x.t + let gen_to_time f x = T.Period.add (T.Period.hour (f x.d * 24)) x.t + let to_time x = gen_to_time D.Period.nb_days x (* eta-expansion required *) + let safe_to_time x = gen_to_time D.Period.safe_nb_days x let ymds x = let y, m, d = D.Period.ymd x.d in @@ -218,30 +223,35 @@ module Make(D: Date_sig.S)(T: Time_sig.S) = struct (*S Arithmetic operations on calendars and periods. *) - let split x = - let t, d = modf (from_gmt (x +. 0.5)) in + let split x = + let t, d = modf (from_gmt (x +. 0.5)) in let t, d = t *. 86400., int_of_float d in let t, d = if t < 0. then t +. 86400., d - 1 else t, d in assert (t >= 0. && t < 86400.); D.from_jd d, T.from_seconds (T.Second.from_float t) let unsplit d t = - to_gmt - (float (D.to_jd d) + to_gmt + (float (D.to_jd d) +. (T.Second.to_float (T.to_seconds t) /. 86400.)) -. 0.5 let add x p = let d, t = split x in - unsplit (D.add d p.Period.d) (T.add t p.Period.t) + unsplit (D.add d (p.Period.d :> D.Period.t)) (T.add t p.Period.t) - let rem x p = add x (Period.opp p) + let rem x p = add x (Period.opp (p :> Period.t)) - let sub x y = - let d1, t1 = split x - and d2, t2 = split y in + let sub x y = + let d1, t1 = split x in + let d2, t2 = split y in Period.normalize { Period.d = D.sub d1 d2; Period.t = T.sub t1 t2 } - let next x f = + let precise_sub x y = + let d1, t1 = split x in + let d2, t2 = split y in + Period.normalize { Period.d = D.precise_sub d1 d2; Period.t = T.sub t1 t2 } + + let next x f = let d, t = split x in match f with | #D.field as f -> unsplit (D.next d f) t @@ -261,12 +271,11 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct module Time = T type t = { date: D.t; time: T.t } - - type day = D.day = Sun | Mon | Tue | Wed | Thu | Fri | Sat + type day = D.day = Sun | Mon | Tue | Wed | Thu | Fri | Sat type month = D.month = Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec - + type year = int type second = T.second @@ -284,12 +293,12 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let hash = Hashtbl.hash (*S Conversions. *) - + let normalize d t = let t, days = T.normalize t in { date = D.add d (D.Period.day days); time = t } - let convert x t1 t2 = + let convert x t1 t2 = let gap = T.Period.hour (Time_Zone.gap t1 t2) in normalize x.date (T.add x.time gap) @@ -304,10 +313,10 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let create d t = to_gmt { date = d; time = t } - let lower_bound, upper_bound = + let lower_bound, upper_bound = let compute () = let midday = T.midday () in - let low, up = + let low, up = create (D.make (-4712) 1 1) midday, create (D.make 3268 1 22) midday in low, up @@ -316,7 +325,7 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let is_valid x = compare x lower_bound >= 0 && compare x upper_bound <= 0 - let make y m d h mn s = + let make y m d h mn s = let x = create (D.make y m d) (T.make h mn s) in if is_valid x then x else raise D.Out_of_bounds @@ -324,22 +333,22 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct ?(second=T.Second.from_int 0) () = make year month day hour minute second - let now () = + let now () = let now = Unix.gettimeofday () in let gmnow = Unix.gmtime now in let frac, _ = modf now in - from_gmt (make - (gmnow.Unix.tm_year + 1900) - (gmnow.Unix.tm_mon + 1) - gmnow.Unix.tm_mday - gmnow.Unix.tm_hour - gmnow.Unix.tm_min + from_gmt (make + (gmnow.Unix.tm_year + 1900) + (gmnow.Unix.tm_mon + 1) + gmnow.Unix.tm_mday + gmnow.Unix.tm_hour + gmnow.Unix.tm_min (T.Second.from_float (float gmnow.Unix.tm_sec +. frac))) let from_jd x = let frac, intf = modf x in - to_gmt - { date = D.from_jd (int_of_float intf); + to_gmt + { date = D.from_jd (int_of_float intf); time = T.from_seconds (T.Second.from_float (frac *. 86400. +. 43200.)) } let from_mjd x = from_jd (x +. 2400000.5) @@ -348,7 +357,7 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let to_jd x = let x = from_gmt x in - float (D.to_jd x.date) +. T.Second.to_float (T.to_seconds x.time) /. 86400. + float (D.to_jd x.date) +. T.Second.to_float (T.to_seconds x.time) /. 86400. -. 0.5 let to_mjd x = to_jd x -. 2400000.5 @@ -376,9 +385,9 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let to_unixtm x = let tm = D.to_unixtm (to_date x) and t = to_time x in - { tm with - Unix.tm_sec = T.Second.to_int (T.second t); - Unix.tm_min = T.minute t; + { tm with + Unix.tm_sec = T.Second.to_int (T.second t); + Unix.tm_min = T.minute t; Unix.tm_hour = T.hour t } let jan_1_1970 = 2440587.5 @@ -395,10 +404,14 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let is_am x = T.is_am (to_time x) (*S Period. *) - + module Period = struct - type t = { d : D.Period.t; t : T.Period.t } + type +'a p = { d : 'a D.Period.period; t : 'a T.Period.period } + constraint 'a = [< Period.date_field ] + + type +'a period = 'a p + type t = Period.date_field period let split x = let rec aux s = @@ -406,7 +419,7 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct in let s = T.Second.to_float (T.Period.length x.t) in let d, s = - if s >= 0. then aux s + if s >= 0. then aux s else let d, s = aux (-. s) in - (d + 1), -. s +. 86400. in assert (s >= 0. && s < 86400.); @@ -418,10 +431,10 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let empty = { d = D.Period.empty; t = T.Period.empty } - let make y m d h mn s = + let make y m d h mn s = normalize { d = D.Period.make y m d; t = T.Period.make h mn s } - let lmake ?(year=0) ?(month=0) ?(day=0) ?(hour=0) ?(minute=0) + let lmake ?(year=0) ?(month=0) ?(day=0) ?(hour=0) ?(minute=0) ?(second=T.Second.from_int 0) () = make year month day hour minute second @@ -434,15 +447,15 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct let minute x = normalize { empty with t = T.Period.minute x } let second x = normalize { empty with t = T.Period.second x } - let add x y = + let add x y = normalize { d = D.Period.add x.d y.d; t = T.Period.add x.t y.t } - let sub x y = + let sub x y = normalize { d = D.Period.sub x.d y.d; t = T.Period.sub x.t y.t } let opp x = normalize { d = D.Period.opp x.d; t = T.Period.opp x.t } - let compare x y = + let compare x y = let n = D.Period.compare x.d y.d in if n = 0 then T.Period.compare x.t y.t else n @@ -456,8 +469,9 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct exception Not_computable = D.Period.Not_computable - let to_time x = - T.Period.add (T.Period.hour (D.Period.nb_days x.d * 24)) x.t + let gen_to_time f x = T.Period.add (T.Period.hour (f x.d * 24)) x.t + let to_time x = gen_to_time D.Period.nb_days x (* eta-expansion required *) + let safe_to_time x = gen_to_time D.Period.safe_nb_days x let ymds x = let y, m, d = D.Period.ymd x.d in @@ -467,13 +481,21 @@ module Make_Precise(D: Date_sig.S)(T: Time_sig.S) = struct (*S Arithmetic operations on calendars and periods. *) - let add x p = normalize (D.add x.date p.Period.d) (T.add x.time p.Period.t) - let rem x p = add x (Period.opp p) + let add x p = + normalize + (D.add x.date (p.Period.d :> D.Period.t)) (T.add x.time p.Period.t) + + let rem x p = add x (Period.opp (p :> Period.t)) - let sub x y = - Period.normalize + let sub x y = + Period.normalize { Period.d = D.sub x.date y.date; Period.t = T.sub x.time y.time } + let precise_sub x y = + Period.normalize + { Period.d = D.precise_sub x.date y.date; + Period.t = T.sub x.time y.time } + let next x = function | #D.field as f -> normalize (D.next x.date f) x.time | #T.field as f -> normalize x.date (T.next x.time f) diff --git a/src/calendar_builder.mli b/src/calendar_builder.mli index baea58d..251b5b3 100644 --- a/src/calendar_builder.mli +++ b/src/calendar_builder.mli @@ -2,36 +2,36 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: calendar_builder.mli,v 1.3 2008/02/05 15:36:21 signoles Exp $ i*) - -(** Generic calendar implementation. +(** Generic calendar implementation. @since 2.0 *) (** Implement a calendar from a date implementation and a time implementation. This module uses float. Then results may be very unprecise. - @since 2.0 *) -module Make(D:Date_sig.S)(T:Time_sig.S) + @since 2.0 *) +module Make(D:Date_sig.S)(T:Time_sig.S) : Calendar_sig.S with module Date = D and module Time = T (** Similar to {!Make} but results are more precise. The counterpart is that some operations are less efficient. - @since 2.0 *) -module Make_Precise(D:Date_sig.S)(T:Time_sig.S) + @since 2.0 *) +module Make_Precise(D:Date_sig.S)(T:Time_sig.S) : Calendar_sig.S with module Date = D and module Time = T diff --git a/src/calendar_sig.mli b/src/calendar_sig.mli index 993eb26..a4abc24 100644 --- a/src/calendar_sig.mli +++ b/src/calendar_sig.mli @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: calendar_sig.mli,v 1.3 2008/02/05 15:36:21 signoles Exp $ i*) - (** Calendar interface. A calendar combines a date and a time: it may be seen as a 6-uple (year, month, day, hour, minute, second). @@ -28,15 +28,12 @@ dates, use this module. The exact Julian period is now [[January, 1st 4713 BC at midday GMT; January 22th, 3268 AC at midday GMT]]. *) -(** Common operations for all calendar representations. +(** Common operations for all calendar representations. @since 2.0 (this signature was before inlined in interface of Calendar). *) module type S = sig (** {2 Datatypes} *) - type t - (** Type of a date refined with a time, so called a calendar. *) - module Date: Date_sig.S (** Date implementation used by this calendar. @since 2.0 *) @@ -45,6 +42,8 @@ module type S = sig (** Time implementation used by this calendar. @since 2.0 *) + type t + type day = Date.day = Sun | Mon | Tue | Wed | Thu | Fri | Sat (** Days of the week. *) @@ -64,17 +63,17 @@ module type S = sig val make : int -> int -> int -> int -> int -> second -> t (** [make year month day hour minute second] makes the calendar - "year-month-day; hour-minute-second". + "year-month-day; hour-minute-second". @raise D.Out_of_bounds when a date is outside the Julian period. @raise D.Undefined when a date belongs to [[October 5th, 1582; October 14th, 1582]]. *) - val lmake : - year:int -> ?month:int -> ?day:int -> + val lmake : + year:int -> ?month:int -> ?day:int -> ?hour:int -> ?minute:int -> ?second:second -> unit -> t - (** Labelled version of [make]. - The default value of [month] and [day] (resp. of [hour], [minute] - and [second]) is [1] (resp. [0]). + (** Labelled version of [make]. + The default value of [month] and [day] (resp. of [hour], [minute] + and [second]) is [1] (resp. [0]). @raise D.Out_of_bounds when a date is outside the Julian period. @raise D.Undefined when a date belongs to [[October 5th, 1582; October 14th, 1582]]. @@ -88,8 +87,8 @@ module type S = sig zone). *) val from_jd : float -> t - (** Return the Julian day. - More precise than [Date.from_jd]: the fractional part represents the + (** Return the Julian day. + More precise than [Date.from_jd]: the fractional part represents the time. *) val from_mjd : float -> t @@ -114,7 +113,7 @@ module type S = sig (** Those functions have the same behavious as those defined in {!Date_sig.S}. *) - + val days_in_month : t -> int (** @see <Date_sig.S.html#VALdays_in_month> Date_sig.S.days_in_month *) @@ -136,9 +135,9 @@ module type S = sig val year : t -> int (** @see <Date_sig.S.html#VALyear> Date_sig.S.year *) - (** [to_jd] and [to_mjd] are more precise than {!Date_sig.S.to_jd} and + (** [to_jd] and [to_mjd] are more precise than {!Date_sig.S.to_jd} and {!Date_sig.S.to_mjd}. *) - + val to_jd : t -> float val to_mjd : t -> float @@ -166,7 +165,7 @@ module type S = sig val hash: t -> int (** Hash function for calendars. - @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash. + @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash. @since 2.0 *) (** Those functions have the same behavious as those defined in @@ -199,18 +198,18 @@ module type S = sig @since 1.01 *) val from_unixtm : Unix.tm -> t - (** Inverse of [to_unixtm]. Assumes the current time zone. + (** Inverse of [to_unixtm]. Assumes the current time zone. So, The following invariant holds: [hour (from_unixtm u) = u.Unix.tm_hour]. @since 1.01 *) val to_unixfloat : t -> float - (** Convert a calendar to a float such than + (** Convert a calendar to a float such than [to_unixfloat (make 1970 1 1 0 0 0)] returns [0.0] at UTC. - So such a float is convertible with those of the module [Unix]. + So such a float is convertible with those of the module [Unix]. More precise than {!Date_sig.S.to_unixfloat}. @since 1.01 *) - + val from_unixfloat : float -> t (** Inverse of [to_unixfloat]. Assumes the current time zone. So, the following invariant holds: @@ -218,14 +217,14 @@ module type S = sig @since 1.01 *) val from_date : Date.t -> t - (** Convert a date to a calendar. + (** Convert a date to a calendar. The time is midnight in the current time zone. *) val to_date : t -> Date.t (** Convert a calendar to a date. Time part of the calendar is ignored. *) val to_time : t -> Time.t - (** Convert a calendar to a time. Date part of the calendar is ignored. + (** Convert a calendar to a time. Date part of the calendar is ignored. @since 1.03 *) (** {2 Period} *) @@ -235,81 +234,119 @@ module type S = sig (** {3 Arithmetic operations} *) - include Period.S + type +'a period constraint 'a = [< Period.date_field ] + type t = Period.date_field period + (** Type of a period. *) + + (** {3 Period is an additive monoid} *) + + val empty : 'a period + (** The empty period. *) + + val add : ([> `Day | `Week ] as 'a) period -> 'a period -> 'a period + (** Addition of periods. *) + + val sub : ([> `Day | `Week ] as 'a) period -> 'a period -> 'a period + (** Substraction of periods. *) + + val opp : ([> `Day | `Week ] as 'a) period -> 'a period + (** Opposite of a period. *) + + (** {3 Periods are comparable} *) + + val equal: 'a period -> 'b period -> bool + (** Equality function between two periods. + @see <Utils.Comparable.html#VALequal> Utils.Comparable.equal + @since 1.09.0 *) + + val compare : 'a period -> 'b period -> int + (** Comparison function between two periods. + @see <Utils.Comparable.html#VALcompare> Utils.Comparable.compare *) + + val hash: 'a period -> int + (** Hash function for periods. + @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash + @since 2.0 *) (** {3 Constructors} *) - + val make : int -> int -> int -> int -> int -> second -> t - (** [make year month day hour minute second] makes a period of the + (** [make year month day hour minute second] makes a period of the specified length. *) - val lmake : - ?year:int -> ?month:int -> ?day:int -> + val lmake : + ?year:int -> ?month:int -> ?day:int -> ?hour:int -> ?minute:int -> ?second:second -> unit -> t - (** Labelled version of [make]. + (** Labelled version of [make]. The default value of each argument is [0]. *) (** Those functions have the same behavious as those defined in {!Date_sig.S.Period}. *) - val year : int -> t + val year : int -> [> `Year ] period (** @see <Date_sig.S.Period.html#VALyear> Date_sig.S.Period.year *) - val month : int -> t + val month : int -> [> `Year | `Month ] period (** @see <Date_sig.S.Period.html#VALmonth> Date_sig.S.Period.month *) - val week : int -> t + val week : int -> [> `Week | `Day ] period (** @see <Date_sig.S.Period.html#VALweek> Date_sig.S.Period.week *) - val day : int -> t + val day : int -> [> `Week | `Day ] period (** @see <Date_sig.S.Period.html#VALday> Date_sig.S.Period.day *) (** Those functions have the same behavious as those defined in {Time_sig.S.Period}. *) - val hour : int -> t + val hour : int -> [> `Week | `Day ] period (** @see <Time_sig.S.Period.html#VALhour> Time_sig.S.Period.hour *) - val minute : int -> t + val minute : int -> [> `Week | `Day] period (** @see <Time_sig.S.Period.html#VALminute> Time_sig.S.Period.minute *) - val second : second -> t + val second : second -> [> `Week | `Day] period (** @see <Time_sig.S.Period.html#VALsecond> Time_sig.S.Period.second *) (** {3 Coercions} *) - - val from_date : Date.Period.t -> t + + val from_date : 'a Date.Period.period -> 'a period (** Convert a date period to a calendar period. *) - val from_time : Time.Period.t -> t + val from_time : 'a Time.Period.period -> 'a period (** Convert a time period to a calendar period. *) - val to_date : t -> Date.Period.t - (** Convert a calendar period to a date period. - The fractional time period is ignored. + val to_date : 'a period -> 'a Date.Period.period + (** Convert a calendar period to a date period. + The fractional time period is ignored. @example [to_date (hour 60)] is equivalent to [Date.Period.days 2]. *) exception Not_computable (** [= Date.Period.Not_computable]. @since 1.04 *) - val to_time : t -> Time.Period.t - (** Convert a calendar period to a date period. + val to_time : 'a period -> 'a Time.Period.period + (** Convert a calendar period to a date period. @raise Not_computable if the time period is not computable. @example [to_time (day 6)] returns a time period of [24 * 3600 * 6 = 518400] seconds @example [to_time (second 30)] returns a time period of [30] seconds @example [to_time (year 1)] raises [Not_computable] because - a year is not a constant number of days. - @since 1.04 *) + a year is not a constant number of days. + @since 1.04 + @deprecated since 2.02: use {!safe_to_time} instead*) + + val safe_to_time: + ([< `Week | `Day ] as 'a) period -> 'a Time.Period.period + (** Equivalent to {!to_time} but never raises any exception. + @since 2.02 *) - val ymds: t -> int * int * int * second + val ymds: 'a period -> int * int * int * second (** Number of years, months, days and seconds in a period. - @example [ymds (make 1 2 3 1 2 3)] returns [1, 2, 3, 3723] + @example [ymds (make 1 2 3 1 2 3)] returns [1, 2, 3, 3723] @example [ymds (make (-1) (-2) (-3) (-1) (-2) (-3)] returns - [-1, -2, -4, 82677]. + [-1, -2, -4, 82677]. @since 1.09.0 *) - + end (** {2 Arithmetic operations on calendars and periods} *) @@ -317,13 +354,17 @@ module type S = sig (** Those functions have the same behavious as those defined in {!Date_sig.S}. *) - val add : t -> Period.t -> t + val add : t -> 'a Period.period -> t (** @see <Date_sig.S.html#VALadd> Date_sig.S.add *) - val sub : t -> t -> Period.t + val sub : t -> t -> [> `Week | `Day ] Period.period (** @see <Date_sig.S.html#VALsub> Date_sig.S.sub *) - val rem : t -> Period.t -> t + val precise_sub : t -> t -> Period.t + (** @see <Date_sig.S.html#VALprecise_sub> Date_sig.S.precise_sub + @since 2.03 *) + + val rem : t -> 'a Period.period -> t (** @see <Date_sig.S.html#VALrem> Date_sig.S.rem *) val next : t -> field -> t diff --git a/src/date.ml b/src/date.ml index 9de2356..2a15a87 100644 --- a/src/date.ml +++ b/src/date.ml @@ -2,48 +2,50 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: date.ml,v 1.35 2009/02/23 10:33:17 signoles Exp $ i*) - (*S Introduction. This module implements operations on dates representing by their Julian day. - Most of the algorithms implemented in this module come from the FAQ + Most of the algorithms implemented in this module come from the FAQ available at~: \begin{center}http://www.tondering.dk/claus/calendar.html\end{center} *) (*S Datatypes. *) -include Utils.Int (* the integer represents the Julian day *) +type field = Period.date_field + +(* the integer represents the Julian day *) +type -'a date = int constraint 'a = [< field ] + +type t = field date type day = Sun | Mon | Tue | Wed | Thu | Fri | Sat -type month = +type month = Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec type year = int -type field = [ `Year | `Month | `Week | `Day ] - (*S Exceptions. *) exception Out_of_bounds - exception Undefined (*S Locale coercions. @@ -59,19 +61,25 @@ external int_of_day : day -> int = "%identity" external month_of_int : int -> month = "%identity" external int_of_month : month -> int = "%identity" +(* Dates are comparable *) + +let compare = Utils.Int.compare +let equal = Utils.Int.equal +let hash = Utils.Int.hash + (* Constructors. *) -let lt (d1 : int * int * int) (d2 : int * int * int) = +let lt (d1 : int * int * int) (d2 : int * int * int) = Pervasives.compare d1 d2 < 0 (* [date_ok] returns [true] is the date belongs to the Julian period; [false] otherwise. *) let date_ok y m d = lt (-4713, 12, 31) (y, m, d) && lt (y, m, d) (3268, 1, 23) -(* Coerce month to the interval ]-oo; 12]. +(* Coerce month to the interval ]-oo; 12]. Note that the used algorithm of [make] does not require any coercion for negative months *) -let coerce_month y m = +let coerce_month y m = if m < 0 then y, m (* (* the below commented lines coerce [m] inside the interval [1;12] @@ -82,7 +90,7 @@ let coerce_month y m = let pred_m = pred m in y + pred_m / 12, pred_m mod 12 + 1 -let make y m d = +let make y m d = let y, m = coerce_month y m in if date_ok y m d then let a = (14 - m) / 12 in @@ -94,28 +102,31 @@ let make y m d = else if lt (y, m, d) (1582, 10, 5) then (* Julian calendar *) d + (153 * m' + 2) / 5 + y' * 365 + y' / 4 - 32083 - else + else raise Undefined - else + else raise Out_of_bounds let lmake ~year ?(month = 1) ?(day = 1) () = make year month day +let make_year y = make y 1 1 +let make_year_month y m = make y m 1 + let current_day day gmt_hour = let hour = Time_Zone.from_gmt () + gmt_hour in (* change the day according to the time zone *) if hour < 0 then begin - assert (hour > - 13); + assert (hour > - 13); day - 1 end else if hour >= 24 then begin assert (hour < 36); day + 1 - end else + end else day let jan_1_1970 = 2440588 -let from_unixfloat x = +let from_unixfloat x = let d = int_of_float (x /. 86400.) + jan_1_1970 in current_day d (Unix.gmtime x).Unix.tm_hour @@ -131,11 +142,11 @@ let to_mjd d = d - 2400001 (*S Useful operations. *) -let is_leap_year y = +let is_leap_year y = if y > 1582 then (* Gregorian calendar *) y mod 4 = 0 && (y mod 100 <> 0 || y mod 400 = 0) else (* Julian calendar *) - if y > (- 45) && y <= (- 8) then + if y > (- 45) && y <= (- 8) then (* every year divisible by 3 is a leap year between 45 BC and 9 BC *) y mod 3 = 0 else if y <= (- 45) || y >= 8 then y mod 4 = 0 @@ -148,17 +159,17 @@ let is_gregorian d = d >= 2299161 (*S Getters. *) -(* [a] and [e] are auxiliary functions for [day_of_month], [month] +(* [a] and [e] are auxiliary functions for [day_of_month], [month] and [year]. *) let a d = d + 32044 -let e d = - let c = - if is_julian d then d + 32082 +let e d = + let c = + if is_julian d then d + 32082 else let a = a d in a - (((4 * a + 3) / 146097) * 146097) / 4 in c - (1461 * ((4 * c + 3) / 1461)) / 4 -let day_of_month d = +let day_of_month d = let e = e d in let m = (5 * e + 2) / 153 in e - (153 * m + 2) / 5 + 1 @@ -167,10 +178,10 @@ let int_month d = let m = (5 * e d + 2) / 153 in m + 3 - 12 * (m / 10) let month d = month_of_int (int_month d - 1) -let year d = - let b, c = +let year d = + let b, c = if is_julian d then 0, d + 32082 - else + else let a = a d in let b = (4 * a + 3) / 146097 in b, a - (b * 146097) / 4 in @@ -197,70 +208,94 @@ let days_in_month d = | Feb -> if is_leap_year (year d) then 29 else 28 (* Boolean operation using some getters. *) -let is_leap_day d = +let is_leap_day d = is_leap_year (year d) && month d = Feb && day_of_month d = 24 let is_valid_date y m d = try let t = make y m d in year t = y && int_month t = m && day_of_month t = d - with Out_of_bounds | Undefined -> + with Out_of_bounds | Undefined -> false (*S Period. *) module Period = struct - (* Cannot use an [int] : periods on months and years have not a constant - number of days. + (* Cannot use an [int] : periods on months and years have not a constant + number of days. For example, if we add a "one year" period [p] to the date 2000-3-12, - [p] corresponds to 366 days (because 2000 is a leap year) and the - resulting date is 2001-3-12 (yep, one year later). But if we add [p] to + [p] corresponds to 366 days (because 2000 is a leap year) and the + resulting date is 2001-3-12 (yep, one year later). But if we add [p] to the date 1999-3-12, [p] corresponds to 365 days and the resulting date is 2000-3-12 (yep, one year later too). *) - type t = { y (* year *) : int; m (* month *) : int; d (* day *) : int } + type +'a period = { m (* month *) : int; d (* day *) : int } + constraint 'a = [< field ] + + type +'a p = 'a period + type t = field period - let empty = { y = 0; m = 0; d = 0 } + let empty = { m = 0; d = 0 } - let make y m d = { y = y; m = m; d = d } + let make y m d = { m = 12 * y + m; d = d } let lmake ?(year = 0) ?(month = 0) ?(day = 0) () = make year month day let day n = { empty with d = n } let week n = { empty with d = 7 * n } let month n = { empty with m = n } - let year n = { empty with y = n } + let year n = { empty with m = 12 * n } - let add x y = { y = x.y + y.y; m = x.m + y.m; d = x.d + y.d } - let sub x y = { y = x.y - y.y; m = x.m - y.m; d = x.d - y.d } - let opp x = { y = - x.y; m = - x.m; d = - x.d } + let add x y = { m = x.m + y.m; d = x.d + y.d } + let sub x y = { m = x.m - y.m; d = x.d - y.d } + let opp x = { m = - x.m; d = - x.d } - (* Lexicographical order over the fields of the type [t]. - Yep, [Pervasives.compare] correctly works. *) - let compare = Pervasives.compare - let equal = Pervasives.(=) + (* exactly equivalent to [Pervasives.compare] but more flexible typing *) + let compare x y = + let n = Pervasives.compare x.m y.m in + if n = 0 then Pervasives.compare x.d y.d else n + let equal x y = compare x y = 0 let hash = Hashtbl.hash exception Not_computable - let nb_days p = if p.y <> 0 || p.m <> 0 then raise Not_computable else p.d + let nb_days p = if p.m <> 0 then raise Not_computable else p.d - let ymd p = p.y, p.m, p.d + let safe_nb_days p = p.d + + let ymd p = p.m / 12, p.m mod 12, p.d end (*S Arithmetic operations on dates and periods. *) -let add d p = -(* Format.printf "%d %d %d / %d %d %d@." - (year d) (int_month d) (day_of_month d) - p.Period.y p.Period.m p.Period.d;*) - make - (year d + p.Period.y) - (int_month d + p.Period.m) - (day_of_month d + p.Period.d) +let add d p = + let y,m,day = Period.ymd p in + make + (year d + y) + (int_month d + m) + (day_of_month d + day) let sub x y = { Period.empty with Period.d = x - y } +let precise_sub y x = + let rec aux m = + if x + 31 * m < y then + aux (m + 1) + else + let y' = add x (Period.month m) in + let d = y - y' in + if d < 0 then + let m = m - 1 in + (* don't use [y'] below: [m] changes *) + m, d + days_in_month (add x (Period.month m)) + else if d >= days_in_month y' then + aux (m + 1) + else + m, d + in + let m, d = aux ((y - x) / 31) in + { Period.m = m; d = d } + let rem d p = add d (Period.opp p) let next d = function @@ -279,7 +314,7 @@ let prev d = function let same_calendar y1 y2 = let d = y1 - y2 in - let aux = + let aux = if is_leap_year y1 then true else if is_leap_year (y1 - 1) then d mod 6 = 0 || d mod 17 = 0 else if is_leap_year (y1 - 2) then d mod 11 = 0 || d mod 17 = 0 @@ -311,7 +346,7 @@ let nth_weekday_of_month y m d n = let first = make y (int_of_month m + 1) 1 in let gap = let diff = int_of_day d - int_day_of_week first in - if diff >= 0 then diff - 7 else diff + if diff >= 0 then diff - 7 else diff in first + 7 * n + gap @@ -330,13 +365,13 @@ let epact y = if y <= 1582 then julian_epact (* Julian calendar *) else (* Gregorian calendar *) let c = y / 100 + 1 (* century *) in - (* 1900 belongs to the 20th century for this algorithm *) + (* 1900 belongs to the 20th century for this algorithm *) abs ((julian_epact - (3 * c) / 4 + (8 * c + 5) / 25 + 8) mod 30) (* [easter] implements the algorithm of Oudin (1940) *) -let easter y = +let easter y = let g = y mod 19 in - let i, j = + let i, j = if y <= 1582 then (* Julian calendar *) let i = (19 * g + 15) mod 30 in i, (y + y / 4 + i) mod 7 @@ -366,13 +401,13 @@ let corpus_christi y = easter y + 60 let from_unixtm x = let d = (* current day at GMT *) - make (x.Unix.tm_year + 1900) (x.Unix.tm_mon + 1) x.Unix.tm_mday + make (x.Unix.tm_year + 1900) (x.Unix.tm_mon + 1) x.Unix.tm_mday in current_day d x.Unix.tm_hour let to_unixtm d = { Unix.tm_sec = 0; Unix.tm_min = 0; Unix.tm_hour = 0; - Unix.tm_mday = day_of_month d; + Unix.tm_mday = day_of_month d; Unix.tm_mon = int_month d - 1; Unix.tm_year = year d - 1900; Unix.tm_wday = int_day_of_week d; @@ -398,8 +433,8 @@ let int_of_day d = let n = int_of_day d in if n = 0 then 7 else n let from_business y w d = if w < 1 || w > weeks_in_year y then invalid_arg "from_business: bad week"; - let first = - try make y 1 1 + let first = + try make y 1 1 with Out_of_bounds | Undefined -> invalid_arg "from_business: bad date" in let first_day = int_day_of_week first in @@ -411,9 +446,9 @@ let from_business y w d = let int_of_day = int_of_day -let day_of_int n = - if n > 0 && n < 7 then day_of_int n - else if n = 7 then day_of_int 0 +let day_of_int n = + if n > 0 && n < 7 then day_of_int n + else if n = 7 then day_of_int 0 else invalid_arg "Not a day" let int_of_month m = int_of_month m + 1 diff --git a/src/date.mli b/src/date.mli index b264c01..7814d3e 100644 --- a/src/date.mli +++ b/src/date.mli @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: date.mli,v 1.29 2008/02/05 15:36:21 signoles Exp $ i*) - (** Date implementation. *) include Date_sig.S diff --git a/src/date_sig.mli b/src/date_sig.mli index b3e6d2d..145619c 100644 --- a/src/date_sig.mli +++ b/src/date_sig.mli @@ -2,65 +2,70 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: date_sig.mli,v 1.5 2008/02/08 13:06:45 signoles Exp $ i*) +(** Date interface. A date may be seen as a triple (year, month, day). -(** Date interface. A date may be seen as a triple (year, month, day). - - All the dates should belong to + All the dates should belong to [[January, 1st 4713 BC; January 22th, 3268 AC]] (called the Julian period). - An [Out_of_bounds] exception is raised if you attempt to create a date + An [Out_of_bounds] exception is raised if you attempt to create a date outside the Julian period. - If a date [d] does not exists and if [d_bef] (resp. [d_aft]) is - the last (resp. first) existing date before (resp. after) [d], + If a date [d] does not exists and if [d_bef] (resp. [d_aft]) is + the last (resp. first) existing date before (resp. after) [d], [d] is automatically coerced to [d_aft + d - d_bef - 1]. - For example, both dates "February 29th, 2003" and - "February 30th, 2003" do not exist and they are coerced respectively to the - date "Mars 1st, 2003" and "Mars 2nd, 2003". + For example, both dates "February 29th, 2003" and + "February 30th, 2003" do not exist and they are coerced respectively to the + date "Mars 1st, 2003" and "Mars 2nd, 2003". This rule is called the coercion rule. - As an exception to the coercion rule, the date belonging to - [[October 5th, 1582; October 14th, 1582]] do not exist and an [Undefined] + As an exception to the coercion rule, the date belonging to + [[October 5th, 1582; October 14th, 1582]] do not exist and an [Undefined] exception is raised if you attempt to create such a date. Those dropped days correspond to the change from the Julian to the Gregorian calendar. *) -(** Common operations for all date representations. +(** Common operations for all date representations. @since 2.0 (this signature was before inlined in interface of Date). *) module type S = sig (** {2 Datatypes} *) + (** The different fields of a date. + @since 2.02 *) + type field = Period.date_field + + (** Type of a date, without specifying any precision level. + @since 2.02 *) + type -'a date constraint 'a = [< field ] + (** Type of a date. *) - type t + type t = field date (** Days of the week. *) type day = Sun | Mon | Tue | Wed | Thu | Fri | Sat (** Months of the year. *) - type month = + type month = Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec (** Year as an [int]. *) type year = int - - (** The different fields of a date. *) - type field = [ `Year | `Month | `Week | `Day ] (** {2 Exceptions} *) @@ -68,33 +73,43 @@ module type S = sig (** Raised when a date is outside the Julian period. *) exception Undefined - (** Raised when a date belongs to + (** Raised when a date belongs to [[October 5th, 1582; October 14th, 1582]]. *) (** {2 Constructors} *) val make : year -> int -> int -> t (** [make year month day] makes the date year-month-day. A BC year [y] - corresponds to the year [-(y+1)]. + corresponds to the year [-(y+1)]. @example years (5 BC) and (1 BC) respectively correspond to years - (-4) and 0. + (-4) and 0. @raise Out_of_bounds when a date is outside the Julian period. @raise Undefined when a date belongs to [[October 5th, 1582; October - 14th, 1582]]. *) + 14th, 1582]]. *) val lmake : year:year -> ?month:int -> ?day:int -> unit -> t - (** Labelled version of [make]. - The default value of [month] and [day] is [1]. + (** Labelled version of [make]. + The default value of [month] and [day] is [1]. @raise Out_of_bounds when a date is outside the Julian period. @raise Undefined when a date belongs to [[October 5th, 1582; October 14th, 1582]]. @since 1.05 *) + val make_year: int -> [< `Year ] date + (** [make_year y] makes a date only represented by its year [y]. The month + and the day of such a date are not relevant. + @since 2.02 *) + + val make_year_month: int -> int -> [< `Year | `Month ] date + (** [make_year_month y m] makes a date only represented by its year [y] and + its month [m]. The day of such a date is not relevant. + @since 2.02 *) + val today : unit -> t (** Date of the current day (based on [Time_Zone.current ()]). *) val from_jd : int -> t - (** Make a date from its Julian day. + (** Make a date from its Julian day. @example [from_jd 0] returns the date 4713 BC-1-1. *) val from_mjd : int -> t @@ -109,16 +124,16 @@ module type S = sig (** {2 Getters} *) - val days_in_month : t -> int + val days_in_month : [> `Year | `Month ] date -> int (** Number of days in the month of a date. @example [days_in_month (make 2003 6 26)] returns [30]. *) val day_of_week : t -> day - (** Day of the week. + (** Day of the week. @example [day_of_week (make 2003 6 26)] returns [Thu]. *) - + val day_of_month : t -> int - (** Day of the month. + (** Day of the month. @example [day_of_month (make 2003 6 26)] returns [26]. *) val day_of_year : t -> int @@ -127,43 +142,43 @@ module type S = sig @example [day_of_year (make 2003 12 28)] returns [362]. *) val week : t -> int - (** Week. + (** Week. @example [week (make 2000 1 3)] returns [1]. @example [week (make 2000 1 2)] returns [52]. @example [week (make 2003 12 28)] returns [52]. @example [week (make 2003 12 29)] returns [1]. *) - val month : t -> month - (** Month. + val month : [> `Month ] date -> month + (** Month. @example [month (make 2003 6 26)] returns [Jun]. *) - val year : t -> year - (** Year. + val year : [> `Year ] date -> year + (** Year. @example [year (make 2003 6 26)] returns [2003]. *) val to_jd : t -> int (** Julian day. @example [to_jd (make (-4712) 1 1)] returns 0. *) - + val to_mjd : t -> int (** Modified Julian day (i.e. Julian day - 2 400 001). - The Modified Julian day is more manageable than the Julian day. + The Modified Julian day is more manageable than the Julian day. @example [to_mjd (make 1858 11 17)] returns 0. *) (** {2 Dates are comparable} *) - - val equal: t -> t -> bool + + val equal: 'a date -> 'b date -> bool (** Equality function between two dates. @see <Utils.Comparable.html#VALequal> Utils.Comparable.equal @since 1.09.0 *) - val compare : t -> t -> int + val compare : 'a date -> 'b date -> int (** Comparison function between two dates. @see <Utils.Comparable.html#VALcompare> Utils.Comparable.compare *) - val hash: t -> int + val hash: 'a date -> int (** Hash function for dates. - @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash + @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash @since 2.0 *) (** {2 Boolean operations on dates} *) @@ -190,9 +205,9 @@ module type S = sig (** {2 Coercions} *) val to_unixtm : t -> Unix.tm - (** Convert a date into the [Unix.tm] type. - The field [is_isdst] is always [false]. The fields [Unix.tm_sec], - [Unix.tm_min] and [Unix.tm_hour] are irrelevant. + (** Convert a date into the [Unix.tm] type. + The field [is_isdst] is always [false]. The fields [Unix.tm_sec], + [Unix.tm_min] and [Unix.tm_hour] are irrelevant. @since 1.01 *) val from_unixtm : Unix.tm -> t @@ -200,9 +215,9 @@ module type S = sig @since 1.01 *) val to_unixfloat : t -> float - (** Convert a date to a float such than [to_unixfloat (make 1970 1 1)] - returns [0.0]. So such a float is convertible with those of the [Unix] - module. The fractional part of the result is always [0]. + (** Convert a date to a float such than [to_unixfloat (make 1970 1 1)] + returns [0.0]. So such a float is convertible with those of the [Unix] + module. The fractional part of the result is always [0]. @since 1.01 *) val from_unixfloat : float -> t @@ -214,25 +229,25 @@ module type S = sig (** Return the "business week" and the day in this week respecting ISO 8601. Notice that business weeks at the beginning and end of the year can sometimes have year numbers which don't match the real year. - @example [to_business (make 2000 1 3)] returns [2000, 1, Mon] + @example [to_business (make 2000 1 3)] returns [2000, 1, Mon] @example [to_business (make 2000 1 2)] returns [1999, 52, Sun] - @example [to_business (make 2003 12 28)] returns [2003, 52, Sun] + @example [to_business (make 2003 12 28)] returns [2003, 52, Sun] @example [to_business (make 2003 12 29)] returns [2004, 1, Mon]. @since 1.09.0 *) val from_business: year -> int -> day -> t (** Inverse of [to_business] respecting ISO-8601. Notice that business weeks at the beginning and end of the year - can sometimes have year numbers which don't match the real year. + can sometimes have year numbers which don't match the real year. @raise Invalid_argument if the date is bad. @since 1.09.0 *) val int_of_day : day -> int (** Convert a day to an integer respecting ISO-8601. So, Monday is 1, Tuesday is 2, ..., and sunday is 7. *) - + val day_of_int : int -> day - (** Inverse of [int_of_day]. + (** Inverse of [int_of_day]. @raise Invalid_argument if the argument does not belong to [1; 7]. *) val int_of_month : month -> int @@ -240,7 +255,7 @@ module type S = sig So, January is 1, February is 2 and so on. *) val month_of_int : int -> month - (** Inverse of [int_of_month]. + (** Inverse of [int_of_month]. @raise Invalid_argument if the argument does not belong to [1; 12]. *) (** {2 Period} *) @@ -249,74 +264,88 @@ module type S = sig module Period : sig (** {3 Arithmetic operations} *) - - include Period.S + + type +'a p constraint 'a = [< field ] + include Period.S with type +'a period = 'a p (** {3 Constructors} *) - val make : int -> int -> int -> t + val make: int -> int -> int -> t (** [make year month day] makes a period of the specified length. *) - val lmake : ?year:int -> ?month:int -> ?day:int -> unit -> t - (** Labelled version of [make]. + val lmake: ?year:int -> ?month:int -> ?day:int -> unit -> t + (** Labelled version of [make]. The default value of each argument is [0]. *) - val year : int -> t + val year: int -> [> `Year ] period (** [year n] makes a period of [n] years. *) - - val month : int -> t + + val month: int -> [> `Year | `Month ] period (** [month n] makes a period of [n] months. *) - val week : int -> t + val week: int -> [> `Week | `Day ] period (** [week n] makes a period of [n] weeks. *) - val day : int -> t + val day: int -> [> `Week | `Day ] period (** [day n] makes a period of [n] days. *) (** {3 Getters} *) - + exception Not_computable (** @since 1.04 *) - - val nb_days : t -> int - (** Number of days in a period. - @raise Not_computable if the number of days is not computable. - @example [nb_days (day 6)] returns [6] + + val nb_days: 'a period -> int + (** Number of days in a period. + @raise Not_computable if the number of days is not computable. + @example [nb_days (day 6)] returns [6] @example [nb_days (year 1)] raises [Not_computable] because a year is not a constant number of days. - @since 1.04 *) + @since 1.04 + @deprecated since 2.02: use {!safe_nb_days} instead *) + + val safe_nb_days: [< `Week | `Day ] period -> int + (** Equivalent to {!nb_days} but never raises any exception. + @since 2.02 *) - val ymd: t -> int * int * int + val ymd: 'a period -> int * int * int (** Number of years, months and days in a period. - @example [ymd (make 1 2 3)] returns [1, 2, 3]. + @example [ymd (make 1 2 3)] returns [1, 2, 3]. @since 1.09.0 *) end (** {2 Arithmetic operations on dates and periods} *) - val add : t -> Period.t -> t + val add : 'a date -> 'a Period.period -> 'a date (** [add d p] returns [d + p]. @raise Out_of_bounds when the resulting date is outside the Julian period. @raise Undefined when the resulting date belongs to [[October 5th, 1582; October 14th, 1582]]. - @example [add (make 2003 12 31) (Period.month 1)] returns the date + @example [add (make 2003 12 31) (Period.month 1)] returns the date 2004-1-31 - @example [add (make 2003 12 31) (Period.month 2)] returns the date + @example [add (make 2003 12 31) (Period.month 2)] returns the date 2004-3-2 (following the coercion rule describes in the introduction). *) - val sub : t -> t -> Period.t + val sub : 'a date -> 'a date -> [> `Week | `Day ] Period.period (** [sub d1 d2] returns the period between [d1] and [d2]. *) - val rem : t -> Period.t -> t - (** [rem d p] is equivalent to [add d (Period.opp p)]. + val precise_sub : 'a date -> 'a date -> Period.t + (** [precise_sub d1 d2] returns the period between [d1] and [d2]. + It is equivalent to [sub], but: + - the period is expressed with a number of years, months and days, not + only with a number of days; + - it is less efficient. + @since 2.03 *) + + val rem : 'a date -> 'a Period.period -> 'a date + (** [rem d p] is equivalent to [add d (Period.opp p)]. @raise Out_of_bounds when the resulting date is outside the Julian period. @raise Undefined when the resulting date belongs to [[October 5th, 1582; October 14th, 1582]]. *) - val next : t -> field -> t + val next : 'a date -> ([< field ] as 'a) -> 'a date (** [next d f] returns the date corresponding to the next specified field. @raise Out_of_bounds when the resulting date is outside the Julian period. @@ -325,8 +354,8 @@ module type S = sig @example [next (make 2003 12 31) `Month] returns the date 2004-1-31 (i.e. one month later). *) - val prev : t -> field -> t - (** [prev d f] returns the date corresponding to the previous specified + val prev : 'a date -> ([< field ] as 'a) -> 'a date + (** [prev d f] returns the date corresponding to the previous specified field. @raise Out_of_bounds when the resulting date is outside the Julian period. @@ -345,7 +374,7 @@ module type S = sig otherwise. *) val days_in_year : ?month:month -> year -> int - (** Number of days in a year. + (** Number of days in a year. [days_in_year ~month y] returns the number of days in the year [y] up to the end of the given month. Thus [days_in_year ~month:Dec y] is the @@ -355,16 +384,16 @@ module type S = sig (** Number of weeks in a year. *) val week_first_last: int -> year -> t * t - (** Return the first and last days of a week in a year. + (** Return the first and last days of a week in a year. @since 1.08 *) val nth_weekday_of_month: year -> month -> day -> int -> t (** [nth_weekday_of_month y m d n] returns the [n]-th day [d] in the month - [m] of the year [y] (for instance the 3rd Thursday of the month). + [m] of the year [y] (for instance the 3rd Thursday of the month). @since 1.09.0 *) val century : year -> int - (** Century of a year. + (** Century of a year. @example [century 2000] returns 20 @example [century 2001] returns 21. *) @@ -374,37 +403,37 @@ module type S = sig @example [millenium 2001] returns 3. *) val solar_number : year -> int - (** Solar number. - + (** Solar number. + In the Julian calendar there is a one-to-one relationship between the Solar number and the day on which a particular date falls. *) val indiction : year -> int - (** Indiction. - - The Indiction was used in the middle ages to specify the position of a + (** Indiction. + + The Indiction was used in the middle ages to specify the position of a year in a 15 year taxation cycle. It was introduced by emperor Constantine the Great on 1 September 312 and ceased to be used in - 1806. - + 1806. + The Indiction has no astronomical significance. *) val golden_number : year -> int - (** Golden number. - + (** Golden number. + Considering that the relationship between the moon's phases and the days of the year repeats itself every 19 years, it is natural to - associate a number between 1 and 19 with each year. + associate a number between 1 and 19 with each year. This number is the so-called Golden number. *) val epact : year -> int - (** Epact. - - The Epact is a measure of the age of the moon (i.e. the number of days + (** Epact. + + The Epact is a measure of the age of the moon (i.e. the number of days that have passed since an "official" new moon) on a particular date. *) - + val easter : year -> t - (** Easter Sunday. + (** Easter Sunday. In the Christian world, Easter (and the days immediately preceding it) is the celebration of the death and resurrection of Jesus in @@ -425,7 +454,7 @@ module type S = sig val palm: year -> t (** Palm Sunday. [palm y] is [easter y - 7]. @since 1.09.0 *) - + val easter_friday: year -> t (** Easter Friday. [easter_friday y] is [easter y - 2]. @since 1.09.0 *) @@ -451,7 +480,7 @@ module type S = sig @since 1.09.0 *) val corpus_christi: year -> t - (** Feast of Corpus Christi. [corpus_christi y] is [easter + 60]. + (** Feast of Corpus Christi. [corpus_christi y] is [easter + 60]. @since 1.09.0 *) end diff --git a/src/fcalendar.ml b/src/fcalendar.ml index fc54f9a..ec49495 100644 --- a/src/fcalendar.ml +++ b/src/fcalendar.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: fcalendar.ml,v 1.2 2008/02/05 15:36:21 signoles Exp $ i*) - include Calendar_builder.Make(Date)(Ftime) module Precise = Calendar_builder.Make_Precise(Date)(Ftime) diff --git a/src/fcalendar.mli b/src/fcalendar.mli index ece6250..973ab62 100644 --- a/src/fcalendar.mli +++ b/src/fcalendar.mli @@ -2,33 +2,33 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: fcalendar.mli,v 1.3 2008/02/05 15:36:21 signoles Exp $ i*) - (** Calendar implementation in which seconds are float. This module uses float. Then results may be very unprecise, especially - comparison of calendars which differ with few seconds. + comparison of calendars which differ with few seconds. In this case, consider to use module [Precise]. @since 2.0 *) include Calendar_sig.S with module Date = Date and module Time = Ftime -(** More precise implementation of calendar in which seconds are float. +(** More precise implementation of calendar in which seconds are float. @since 2.0 *) module Precise: Calendar_sig.S with module Date = Date and module Time = Ftime diff --git a/src/ftime.ml b/src/ftime.ml index 37e7e5b..c746bb2 100644 --- a/src/ftime.ml +++ b/src/ftime.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: ftime.ml,v 1.4 2008/02/05 15:36:21 signoles Exp $ i*) - (*S Introduction. A time is represents by a number of seconds in UTC. @@ -46,7 +46,7 @@ let from_gmt t = convert t Time_Zone.UTC (Time_Zone.current ()) let to_gmt t = convert t (Time_Zone.current ()) Time_Zone.UTC (* Coerce [t] into the interval $[0; 86400[$ (i.e. a one day interval). *) -let normalize t = +let normalize t = let t = from_gmt t in let t_mod, t_div = to_gmt (mod_float t fone_day), int_of_float t / one_day in if t < 0. then t_mod +. fone_day, t_div - 1 else t_mod, t_div @@ -65,8 +65,8 @@ let now () = let now = Unix.gettimeofday () in let gmnow = Unix.gmtime now in let frac, _ = modf now in - float - (3600 * gmnow.Unix.tm_hour + 60 * gmnow.Unix.tm_min + gmnow.Unix.tm_sec) + float + (3600 * gmnow.Unix.tm_hour + 60 * gmnow.Unix.tm_min + gmnow.Unix.tm_sec) +. frac (*S Getters. *) @@ -81,13 +81,13 @@ let to_seconds t = from_gmt t (*S Boolean operations. *) -let is_pm t = - let t, _ = normalize t in +let is_pm t = + let t, _ = normalize t in let m, _ = normalize (midday ()) in t < m -let is_am t = - let t, _ = normalize t in +let is_am t = + let t, _ = normalize t in let m, _ = normalize (midday ()) in t >= m @@ -111,6 +111,7 @@ end module Period = struct + type +'a period = float constraint 'a = [< Period.date_field ] include Utils.Float let make h m s = float (h * 3600 + m * 60) +. s diff --git a/src/ftime.mli b/src/ftime.mli index 00c46cd..61d4344 100644 --- a/src/ftime.mli +++ b/src/ftime.mli @@ -2,25 +2,25 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: ftime.mli,v 1.4 2008/02/05 15:36:21 signoles Exp $ i*) - -(** Time implementation in which seconds are floats. +(** Time implementation in which seconds are floats. This module uses float. Then results may be very unprecise. @since 2.0 *) diff --git a/src/period.mli b/src/period.mli index 5e9c89f..a00fdc2 100644 --- a/src/period.mli +++ b/src/period.mli @@ -2,63 +2,66 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: period.mli,v 1.16 2008/02/05 15:36:21 signoles Exp $ i*) - (** A period represents the time passed between two events (a date, a time...). Only an interface defining arithmetic operations on periods is defined here. An implementation of this interface depends on the kind of an event (see module [Time.Period], [Date.Period] and [Calendar.Period]). *) +type date_field = [ `Year | `Month | `Week | `Day ] + (** Common interface for all periods. *) module type S = sig - type t + type +'a period constraint 'a = [< date_field ] + type t = date_field period (** Type of a period. *) (** {3 Period is an additive monoid} *) - val empty : t + val empty : 'a period (** The empty period. *) - val add : t -> t -> t + val add : 'a period -> 'a period -> 'a period (** Addition of periods. *) - val sub : t -> t -> t + val sub : 'a period -> 'a period -> 'a period (** Substraction of periods. *) - val opp : t -> t + val opp : 'a period -> 'a period (** Opposite of a period. *) (** {3 Periods are comparable} *) - val equal: t -> t -> bool + val equal: 'a period -> 'b period -> bool (** Equality function between two periods. @see <Utils.Comparable.html#VALequal> Utils.Comparable.equal @since 1.09.0 *) - val compare : t -> t -> int + val compare : 'a period -> 'b period -> int (** Comparison function between two periods. @see <Utils.Comparable.html#VALcompare> Utils.Comparable.compare *) - val hash: t -> int + val hash: 'a period -> int (** Hash function for periods. - @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash + @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash @since 2.0 *) end diff --git a/src/printer.ml b/src/printer.ml index d937f27..785fe9f 100644 --- a/src/printer.ml +++ b/src/printer.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: printer.ml,v 1.20 2009/01/26 09:00:58 signoles Exp $ i*) - module type S = sig type t diff --git a/src/printer.mli b/src/printer.mli index f91d059..3cf6d08 100644 --- a/src/printer.mli +++ b/src/printer.mli @@ -2,38 +2,38 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: printer.mli,v 1.22 2009/01/26 09:08:10 signoles Exp $ i*) - -(** Pretty printing and parsing from string. +(** Pretty printing and parsing from string. In the following, an "event" is either a date or a time or a calendar. - + This module implements different printers: one for each kind of events. - The three printers have the same signature: + The three printers have the same signature: they mainly implement a [fprint : string -> formatter -> t -> unit] function and a [from_fstring : string -> string -> t] function. - The first one prints an event according to a format string - (see below for a description of such a format). + The first one prints an event according to a format string + (see below for a description of such a format). The second one converts a string to an event according to a format string. - A format string follows the unix utility 'date' (with few modifications). - It is a string which contains two types of objects: plain characters and - conversion specifiers. Those specifiers are introduced by + A format string follows the unix utility 'date' (with few modifications). + It is a string which contains two types of objects: plain characters and + conversion specifiers. Those specifiers are introduced by a [%] character and their meanings are: - [%%]: a literal [%] - [%a]: short day name (by using a short version of [day_name]) @@ -71,32 +71,33 @@ - [%Y]: year (four digits) - [%z]: time zone in the form +hhmm (e.g. -0400) (since version 2.01) - [%:z]: time zone in the form +hh:mm (e.g. -04:00) (since version 2.01) - - [%::z]: time zone in the form +hh:mm:ss (e.g. -04:00:00) (since version 2.01) + - [%::z]: time zone in the form +hh:mm:ss (e.g. -04:00:00) + (since version 2.01) - [%:::z]: time zone in the form +hh (e.g. -04) (since version 2.01) - By default, date pads numeric fields with zeroes. Two special modifiers + By default, date pads numeric fields with zeroes. Two special modifiers between [`%'] and a numeric directive are recognized: - ['-' (hyphen)]: do not pad the field - ['_' (underscore)]: pad the field with spaces - ['0' (zero)]: pad the field with zeroes (default) (since version 2.01) - ['^']: use uppercase if possible (since version 2.01) Padding is only available for printers, not for parsers. - + @example a possible output of [%D] is [01/06/03] - @example a possible output of [the date is %B, the %-dth] is + @example a possible output of [the date is %B, the %-dth] is [the date is January, the 6th] is matched by ; - @example a possible output of [%c] is [Thu Sep 18 14:10:51 2003]. + @example a possible output of [%c] is [Thu Sep 18 14:10:51 2003]. @since 1.05 *) -(** {2 Internationalization} +(** {2 Internationalization} You can manage the string representations of days and months. By default, the English names are used but you can change their by setting the references [day_name] and [month_name]. - @example - [day_name := function Date.Mon -> "lundi" | Date.Tue -> "mardi" | + @example + [day_name := function Date.Mon -> "lundi" | Date.Tue -> "mardi" | Date.Wed -> "mercredi" | Date.Thu -> "jeudi" | Date.Fri -> "vendredi" | Date.Sat -> "samedi" | Date.Sun -> "dimanche"] sets the names of the days to the French names. *) @@ -105,28 +106,28 @@ val day_name : (Date.day -> string) ref (** String representation of a day. *) val name_of_day : Date.day -> string -(** [name_of_day d] is equivalent to [!day_name d]. +(** [name_of_day d] is equivalent to [!day_name d]. Used by the specifier [%A]. *) val short_name_of_day : Date.day -> string -(** [short_name_of_day d] returns the 3 first characters of [name_of_day d]. +(** [short_name_of_day d] returns the 3 first characters of [name_of_day d]. Used by the specifier [%a]. *) val month_name : (Date.month -> string) ref (** String representation of a month. *) - + val name_of_month : Date.month -> string -(** [name_of_month m] is equivalent to [!day_month m]. +(** [name_of_month m] is equivalent to [!day_month m]. Used by the specifier [%B]. *) val short_name_of_month : Date.month -> string -(** [short_name_of_month d] returns the 3 first characters of - [name_of_month d]. +(** [short_name_of_month d] returns the 3 first characters of + [name_of_month d]. Used by the specifier [%b]. *) val set_word_regexp: Str.regexp -> unit (** Set the regular expression used to recognize words in - [from_fstring]. Default is [[a-zA-Z]*]. + [from_fstring]. Default is [[a-zA-Z]*]. @since 1.10 *) (** {2 Printers (including parsers from string)} @@ -136,25 +137,25 @@ val set_word_regexp: Str.regexp -> unit (** Generic signature of a printer-parser. *) module type S = sig - type t + type t (** Generic type of a printer. *) val fprint : string -> Format.formatter -> t -> unit (** [fprint format formatter x] outputs [x] on [formatter] according to - the specified [format]. + the specified [format]. @raise Invalid_argument if the format is incorrect. *) - + val print : string -> t -> unit (** [print format] is equivalent to [fprint format Format.std_formatter] *) val dprint : t -> unit - (** Same as [print d] where [d] is the default format + (** Same as [print d] where [d] is the default format (see the printer implementations). *) val sprint : string -> t -> string (** [sprint format date] converts [date] to a string according to [format]. *) - + val to_string : t -> string (** Same as [sprint d] where [d] is the default format (see the printer implementations). *) @@ -173,11 +174,11 @@ module type S = sig regular expression is used which can be configured by {!Printer.set_word_regexp}. When the format has only two digits for the year number, 1900 are added to this number (see examples). - + @raise Invalid_argument if either the format is incorrect or the string does not match the format or the event cannot be created (e.g. if you do not specify a year for a date). - + @example [from_fstring "the date is %D" "the date is 01/06/03"] returns a date equivalent to [Date.make 1903 1 6] @example [from_fstring "the date is %B, the %dth %Y" "the date is May, @@ -191,7 +192,7 @@ end (** Date printer. Specifiers which use time functionalities are not available on this printer. - Default format is [%i]. + Default format is [%i]. @since 2.0 *) module Date: S with type t = Date.t @@ -200,7 +201,7 @@ module DatePrinter: S with type t = Date.t (** Time printer. Specifiers which use date functionalities are not available on this printer. - Default format is [%T]. + Default format is [%T]. @since 2.0 *) module Time: S with type t = Time.t @@ -210,28 +211,28 @@ module TimePrinter : S with type t = Time.t (** Ftime printer. Seconds are rounded to integers before pretty printing. Specifiers which use date functionalities are not available on this printer. - Default format is [%T]. + Default format is [%T]. @since 2.0 *) module Ftime: S with type t = Ftime.t -(** Precise Calendar printer. Default format is [%i %T]. +(** Precise Calendar printer. Default format is [%i %T]. @since 2.0 *) module Precise_Calendar: S with type t = Calendar.Precise.t -(** Calendar printer. Default format is [%i %T]. +(** Calendar printer. Default format is [%i %T]. @since 2.0 *) module Calendar: S with type t = Calendar.t (** @deprecated Replaced by {!Printer.Calendar}. *) module CalendarPrinter: S with type t = Calendar.t -(** Precise Fcalendar printer. +(** Precise Fcalendar printer. Seconds are rounded to integers before pretty printing. - Default format is [%i %T]. + Default format is [%i %T]. @since 2.0 *) module Precise_Fcalendar: S with type t = Fcalendar.Precise.t (** Fcalendar printer. Seconds are rounded to integers before pretty printing. - Default format is [%i %T]. + Default format is [%i %T]. @since 2.0 *) module Fcalendar: S with type t = Fcalendar.t diff --git a/src/time.ml b/src/time.ml index f52a3c7..191a446 100644 --- a/src/time.ml +++ b/src/time.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: time.ml,v 1.22 2008/02/05 15:36:21 signoles Exp $ i*) - (*S Introduction. A time is represents by a number of seconds in UTC. @@ -44,7 +44,7 @@ let from_gmt t = convert t Time_Zone.UTC (Time_Zone.current ()) let to_gmt t = convert t (Time_Zone.current ()) Time_Zone.UTC (* Coerce [t] into the interval $[0; 86400[$ (i.e. a one day interval). *) -let normalize t = +let normalize t = let t = from_gmt t in let t_mod, t_div = to_gmt (t mod one_day), t / one_day in if t < 0 then t_mod + one_day, t_div - 1 else t_mod, t_div @@ -74,13 +74,13 @@ let to_seconds t = from_gmt t (*S Boolean operations. *) -let is_pm t = - let t, _ = normalize t in +let is_pm t = + let t, _ = normalize t in let m, _ = normalize (midday ()) in t < m -let is_am t = - let t, _ = normalize t in +let is_am t = + let t, _ = normalize t in let m, _ = normalize (midday ()) in t >= m @@ -104,6 +104,7 @@ end module Period = struct + type +'a period = int constraint 'a = [< Period.date_field ] include Utils.Int let make h m s = h * 3600 + m * 60 + s diff --git a/src/time.mli b/src/time.mli index f4e2c62..1454153 100644 --- a/src/time.mli +++ b/src/time.mli @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: time.mli,v 1.20 2008/02/05 15:36:21 signoles Exp $ i*) - (** Time implementation in which seconds are integers. *) include Time_sig.S with type second = int diff --git a/src/time_Zone.ml b/src/time_Zone.ml index 1b2fc3f..3915207 100644 --- a/src/time_Zone.ml +++ b/src/time_Zone.ml @@ -2,27 +2,27 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: time_Zone.ml,v 1.10 2008/02/05 15:36:21 signoles Exp $ i*) - -type t = +type t = | UTC - | Local + | Local | UTC_Plus of int let tz = ref UTC @@ -37,7 +37,7 @@ let make_in_bounds x = else if y > 11 then y - 24 else y -let gap_gmt_local = +let gap_gmt_local = let t = Unix.time () in (Unix.localtime t).Unix.tm_hour - (Unix.gmtime t).Unix.tm_hour @@ -48,7 +48,7 @@ let change = function | _ as t -> tz := t let gap t1 t2 = - let aux t1 t2 = + let aux t1 t2 = assert (t1 < t2); match t1, t2 with | UTC, Local -> gap_gmt_local @@ -56,8 +56,8 @@ let gap t1 t2 = | Local, UTC_Plus x -> x - gap_gmt_local | UTC_Plus x, UTC_Plus y -> y - x | _ -> assert false - in - let res = + in + let res = if t1 = t2 then 0 else if t1 < t2 then aux t1 t2 else - aux t2 t1 @@ -67,7 +67,7 @@ let gap t1 t2 = let from_gmt () = gap UTC (current ()) let to_gmt () = gap (current ()) UTC -let is_dst () = +let is_dst () = current () = Local && (Unix.localtime (Unix.time ())).Unix.tm_isdst let hour_of_dst () = if is_dst () then 1 else 0 diff --git a/src/time_Zone.mli b/src/time_Zone.mli index ee758f0..6349453 100644 --- a/src/time_Zone.mli +++ b/src/time_Zone.mli @@ -2,30 +2,30 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: time_Zone.mli,v 1.12 2008/02/05 15:36:21 signoles Exp $ i*) - (** Time zone management. You can [change] the [current] time zone in your program by side effect. *) (** Type of a time zone. *) -type t = +type t = | UTC (** Greenwich Meridian Time *) | Local (** Local Time *) | UTC_Plus of int (** Another time zone specified from UTC *) @@ -34,10 +34,10 @@ val current : unit -> t (** Return the current time zone. It is [UTC] before any change. *) val change : t -> unit - (** Change the current time zone by another one. + (** Change the current time zone by another one. Raise [Invalid_argument] if the specified time zone is [UTC_Plus x] with [x < -12] or [x > 11] *) - + val gap : t -> t -> int (** Return the gap between two time zone. @example [gap UTC (UTC_Plus 5)] returns 5 and, at Paris in summer, @@ -52,15 +52,15 @@ val to_gmt : unit -> int val is_dst : unit -> bool (** [is_dst ()] checks if daylight saving time is in effect. Only relevant in local time. - Returns alway [false] in another time zone. + Returns alway [false] in another time zone. @since 1.09.4 *) val hour_of_dst : unit -> int - (** [hour_of_dst ()] returns [1] if [is_dst ()] and [0] otherwise. + (** [hour_of_dst ()] returns [1] if [is_dst ()] and [0] otherwise. @since 1.09.4 *) val on: ('a -> 'b) -> t -> 'a -> 'b (** [on f tz x] changes the time zone to [tz], then computes [f x], and finally reset the time zone to the initial one and returns the result of - the computation. - @since 2.0 *) + the computation. + @since 2.0 *) diff --git a/src/time_sig.mli b/src/time_sig.mli index db8d7f2..b8083fd 100644 --- a/src/time_sig.mli +++ b/src/time_sig.mli @@ -2,39 +2,39 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: time_sig.mli,v 1.4 2008/02/05 15:36:21 signoles Exp $ i*) - -(** Time interface. A time may be seen as a triple (hour, minute, second). +(** Time interface. A time may be seen as a triple (hour, minute, second). If minutes and seconds do not belong to [\[0; 60\[], they are coerced into - this interval. + this interval. @example "30 hours, 60 minutes, 80 seconds" is coerced to "31 hours, 1 minute, 20 seconds". - Each time is interpreted in the current time zone (given by - [Time_Zone.current ()]). So, if you change the time zone (by - {!Time_Zone.change}), each time consequently changes. - If you want to express a time in another time zone (and do not affect + Each time is interpreted in the current time zone (given by + [Time_Zone.current ()]). So, if you change the time zone (by + {!Time_Zone.change}), each time consequently changes. + If you want to express a time in another time zone (and do not affect others times), use the [convert] function. *) -(** Interface for seconds. +(** Interface for seconds. @since 2.0 *) module type Second = sig @@ -55,7 +55,7 @@ module type Second = sig end -(** Common operations for all time representations. +(** Common operations for all time representations. @since 2.0 (this signature was before inlined in interface of Time). *) module type S = sig @@ -70,7 +70,7 @@ module type S = sig (** {2 Second} *) type second - (** Type of a second. + (** Type of a second. @since 2.0 (was an integer in previous versions). *) (** Second implementation @@ -78,21 +78,21 @@ module type S = sig module Second: Second with type t = second (** {2 Constructors} *) - + val make : int -> int -> second -> t (** [make hour minute second] makes the time hour-minute-second. *) val lmake : ?hour:int -> ?minute:int -> ?second:second -> unit -> t - (** Labelled version of [make]. The default value is [0] for each argument. + (** Labelled version of [make]. The default value is [0] for each argument. @since 1.05 *) val now : unit -> t (** The current time based on [Time_Zone.current ()]. *) - + val midnight : unit -> t (** [midnight ()] is midnight (expressed in the current time zone). So, it has always the same behaviour as [make 0 0 0]. *) - + val midday : unit -> t (** [midday ()] is midday (expressed in the current time zone). So, it has always the same behaviour as [make 12 0 0]. *) @@ -110,13 +110,13 @@ module type S = sig [convert t Time_Zone.GMT (Time_Zone.current ())]. *) val to_gmt : t -> t - (** [to_gmt t] is equivalent to + (** [to_gmt t] is equivalent to [convert t (Time_Zone.current ()) Time_Zone.GMT]. *) val normalize : t -> t * int (** [normalize t] returns [t] such that [hour t] belongs to [\[0; 24\[]. The second component of the result is the number of days needed by the - modification. + modification. @example [normalize (make 22 0 0)] returns the time 22-0-0 and 0, [normalize (make 73 0 0)] returns the time 1-0-0 and 3 and [normalize (make (-73) 0 0)] returns the time 23-0-0 and (-4). *) @@ -124,33 +124,33 @@ module type S = sig (** {2 Getters} *) val hour : t -> int - (** Hour. + (** Hour. @example [hour (make 20 0 0)] returns 20. *) val minute : t -> int - (** Minute. + (** Minute. @example [minute (make 20 10 0)] returns 10. *) val second : t -> second - (** Second. + (** Second. @example [second (make 20 10 5)] returns 5. *) val to_seconds : t -> second - (** Number of seconds of a time. + (** Number of seconds of a time. @example [to_seconds (make 1 2 3)] returns [3600 + 120 + 3 = 3723]. *) val to_minutes : t -> float - (** Number of minutes of a time. The resulting fractional part represents + (** Number of minutes of a time. The resulting fractional part represents seconds. @example [to_minutes (make 1 2 3)] returns [60+2+0.05 = 62.05]. *) val to_hours : t -> float - (** Number of hours of a time. The resulting fractional part represents + (** Number of hours of a time. The resulting fractional part represents minutes and seconds. @example [to_hours (make 1 3 0)] returns [1 + 0.05 = 1.05]. *) (** {2 Times are comparable} *) - + val equal: t -> t -> bool (** Equality function between two times. @see <Utils.Comparable.html#VALequal> Utils.Comparable.equal. @@ -162,7 +162,7 @@ module type S = sig val hash: t -> int (** Hash function for times. - @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash. + @see <Utils.Comparable.html#VALhash> Utils.Comparable.hash. @since 2.0 *) (** {2 Boolean operations on times} *) @@ -170,13 +170,13 @@ module type S = sig val is_pm : t -> bool (** Return [true] is the time is before midday in the current time zone; [false] otherwise. - @example both [is_pm (make 10 0 0)] and [is_pm (make 34 0 0)] return + @example both [is_pm (make 10 0 0)] and [is_pm (make 34 0 0)] return [true]. *) val is_am : t -> bool - (** Return [true] is the time is after midday in the current time zone; - [false] otherwise. - @example both [is_am (make 20 0 0)] and [is_am (make 44 0 0)] return + (** Return [true] is the time is after midday in the current time zone; + [false] otherwise. + @example both [is_am (make 20 0 0)] and [is_am (make 44 0 0)] return [true]. *) (** {2 Coercions} *) @@ -197,67 +197,67 @@ module type S = sig (** {3 Arithmetic operations} *) - include Period.S + include Period.S - val length : t -> second + val length : 'a period -> second (** Number of seconds of a period. *) - val mul : t -> t -> t + val mul : 'a period -> 'a period -> 'a period (** Multiplication. *) - val div : t -> t -> t + val div : 'a period -> 'a period -> 'a period (** Division. *) (** {3 Constructors} *) - val make : int -> int -> second -> t + val make : int -> int -> second -> 'a period (** [make hour minute second] makes a period of the specified length. *) - val lmake : ?hour:int -> ?minute:int -> ?second:second -> unit -> t - (** Labelled version of [make]. + val lmake : ?hour:int -> ?minute:int -> ?second:second -> unit -> 'a period + (** Labelled version of [make]. The default value is [0] for each argument. *) - val hour : int -> t + val hour : int -> 'a period (** [hour n] makes a period of [n] hours. *) - val minute : int -> t + val minute : int -> 'a period (** [minute n] makes a period of [n] minutes. *) - val second : second -> t + val second : second -> 'a period (** [second n] makes a period of [n] seconds. *) (** {3 Getters} *) - val to_seconds : t -> second - (** Number of seconds of a period. - @example [to_seconds (make 1 2 3)] returns [3600 + 120 + 3 = 3723]. + val to_seconds : 'a period -> second + (** Number of seconds of a period. + @example [to_seconds (make 1 2 3)] returns [3600 + 120 + 3 = 3723]. @since 1.04 *) - val to_minutes : t -> float - (** Number of minutes of a period. The resulting fractional part + val to_minutes : 'a period -> float + (** Number of minutes of a period. The resulting fractional part represents seconds. - @example [to_minutes (make 1 2 3)] returns [60 + 2 + 0.05 = 62.05]. + @example [to_minutes (make 1 2 3)] returns [60 + 2 + 0.05 = 62.05]. @since 1.04 *) - val to_hours : t -> float - (** Number of hours of a period. The resulting fractional part represents + val to_hours : 'a period -> float + (** Number of hours of a period. The resulting fractional part represents minutes and seconds. - @example [to_hours (make 1 3 0)] returns [1 + 0.05 = 1.05]. + @example [to_hours (make 1 3 0)] returns [1 + 0.05 = 1.05]. @since 1.04 *) end (** {2 Arithmetic operations on times and periods} *) - val add : t -> Period.t -> t - (** [app t p] returns [t + p]. + val add : t -> 'a Period.period -> t + (** [app t p] returns [t + p]. @example [add (make 20 0 0) (Period.minute 70)] returns the time 21:10:0. *) - val sub : t -> t -> Period.t + val sub : t -> t -> 'a Period.period (** [sub t1 t2] returns the period between [t1] and [t2]. *) - val rem : t -> Period.t -> t + val rem : t -> 'a Period.period -> t (** [rem t p] is equivalent to [add t (Period.opp p)]. *) val next : t -> field -> t @@ -267,7 +267,7 @@ module type S = sig val prev : t -> field -> t (** [prev t f] returns the time corresponding to the previous specified - field. + field. @example [prev (make 20 3 31) `Second] returns the time 20:03:30 (i.e. one second ago). *) diff --git a/src/utils.ml b/src/utils.ml index 8f3479d..9fea0d9 100644 --- a/src/utils.ml +++ b/src/utils.ml @@ -2,24 +2,24 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(* $Id: utils.ml,v 1.2 2008/02/05 15:36:21 signoles Exp $ *) - module type Comparable = sig type t val equal: t -> t -> bool @@ -44,8 +44,8 @@ module Float = struct let equal x y = abs_float (x -. y) < !precision - let compare x y = - if equal x y then 0 + let compare x y = + if equal x y then 0 else if x < y then -1 else 1 diff --git a/src/utils.mli b/src/utils.mli index aebe266..9b43824 100644 --- a/src/utils.mli +++ b/src/utils.mli @@ -2,28 +2,28 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(* $Id: utils.mli,v 1.2 2008/02/05 15:36:21 signoles Exp $ *) - -(** Some utilities. +(** Some utilities. @since 2.0 *) -(** Interface for comparable and hashable types. +(** Interface for comparable and hashable types. Modules implementing this interface can be an argument of [Map.Make], [Set.Make] or [Hashtbl.Make]. @since 2.0 *) @@ -31,32 +31,32 @@ module type Comparable = sig type t - val equal: t -> t -> bool + val equal: t -> t -> bool (** Equality over [t]. *) - val compare: t -> t -> int - (** Comparison over [t]. + val compare: t -> t -> int + (** Comparison over [t]. [compare x y] returns [0] iff [equal x y = 0]. If [x] and [y] are not equal, it returns a negative integer iff [x] is lesser than [y] and a positive integer otherwise. *) - val hash: t -> int + val hash: t -> int (** A hash function over [t]. *) end -(** Integer implementation. +(** Integer implementation. @since 2.0 *) module Int: Comparable with type t = int -(** Float implementation. +(** Float implementation. @since 2.0 *) module Float: sig include Comparable with type t = float val set_precision: float -> unit - (** Set the precision of [equal] and [compare] for float. + (** Set the precision of [equal] and [compare] for float. If the precision is [p], then the floats [x] and [y] are equal iff [abs(x-y) < p]. By default, the precision is [1e-3] (that is one millisecond if floats represents seconds). *) diff --git a/src/version.mli b/src/version.mli index f62e6a1..00cc41a 100644 --- a/src/version.mli +++ b/src/version.mli @@ -2,25 +2,25 @@ (* *) (* This file is part of Calendar. *) (* *) -(* Copyright (C) 2003-2008 Julien Signoles *) +(* Copyright (C) 2003-2010 Julien Signoles *) (* *) (* you can redistribute it and/or modify it under the terms of the GNU *) (* Lesser General Public License version 2.1 as published by the *) -(* Free Software Foundation. *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) (* *) (* It is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) -(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) -(* GNU Lesser General Public License for more details. *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) (* *) (* See the GNU Lesser General Public Licence version 2.1 for more *) (* details (enclosed in the file LGPL). *) (* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) (**************************************************************************) -(*i $Id: version.mli,v 1.8 2008/02/05 15:36:21 signoles Exp $ i*) - -(** Information about version of calendar. +(** Information about version of calendar. @since 2.0 *) val version: string diff --git a/tests/.cvsignore b/tests/.cvsignore deleted file mode 100644 index 9daeafb..0000000 --- a/tests/.cvsignore +++ /dev/null @@ -1 +0,0 @@ -test diff --git a/tests/gen_test.ml b/tests/gen_test.ml index 6f49d47..5b8bebe 100644 --- a/tests/gen_test.ml +++ b/tests/gen_test.ml @@ -1,4 +1,26 @@ -(*i $Id: gen_test.ml,v 1.2 2008/02/01 10:48:33 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: gen_test.ml 231 2010-07-05 07:54:31Z signoles $ i*) let ok_ref = ref 0 let ok () = incr ok_ref diff --git a/tests/gen_test.mli b/tests/gen_test.mli index fb9d719..346f592 100644 --- a/tests/gen_test.mli +++ b/tests/gen_test.mli @@ -1,4 +1,26 @@ -(*i $Id: gen_test.mli,v 1.1 2003/07/09 07:17:08 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: gen_test.mli 231 2010-07-05 07:54:31Z signoles $ i*) (* Generic functions used in the tests. *) diff --git a/tests/test.ml b/tests/test.ml index 9102007..9943793 100644 --- a/tests/test.ml +++ b/tests/test.ml @@ -1,4 +1,26 @@ -(*i $Id: test.ml,v 1.6 2008/07/07 09:42:17 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test.ml 231 2010-07-05 07:54:31Z signoles $ i*) (* Display the results *) diff --git a/tests/test_calendar.ml b/tests/test_calendar.ml index 9140d1d..7495468 100644 --- a/tests/test_calendar.ml +++ b/tests/test_calendar.ml @@ -1,4 +1,24 @@ -(*i $Id: test_calendar.ml,v 1.18 2008/02/08 10:36:14 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) Printf.printf "Tests of Calendar:\n";; @@ -18,36 +38,72 @@ test (make (-4712) 1 1 12 0 0 = make (-4712) 1 0 36 0 0) "calendar coercion";; test (from_jd 0. = make (-4712) 1 1 12 0 0) "from_jd 0 = 4713 BC-1-1";; test (from_mjd 0. = make 1858 11 17 0 0 0) "from_mjd 0 = 1858-11-17";; +test (Precise.compare (Precise.make 2009 12 14 13 49 0) (Precise.make 2009 12 14 13 49 1) < 0) + "Precise.compare 2009/12/14/13/19/0 2009/12/14/13/19/1";; + +Utils.Float.set_precision 1e-5;; +test (compare (make 2009 12 14 13 49 0) (make 2009 12 14 13 49 1) < 0) + "compare 2009/12/14/13/19/0 2009/12/14/13/19/1";; +Utils.Float.set_precision 1e-3;; + Time_Zone.change (Time_Zone.UTC_Plus 5);; -test (abs_float (to_jd (from_jd 12345.6789) -. 12345.6789) < eps) +test (abs_float (to_jd (from_jd 12345.6789) -. 12345.6789) < eps) "to_jd (from_jd x) = x";; -test (abs_float (to_mjd (from_mjd 12345.6789) -. 12345.6789) < eps) +test (abs_float (to_mjd (from_mjd 12345.6789) -. 12345.6789) < eps) "to_mjd (from_mjd x) = x";; -test (Period.to_date (Period.hour 60) = Date.Period.day 2) +test (Period.to_date (Period.hour 60) = Date.Period.day 2) "period(60h) = period(2d)";; test (Period.compare (Period.day 2) (Period.hour 60) < 0) "Period.compare <";; test (Period.compare (Period.day 3) (Period.hour 60) > 0) "Period.compare >";; -test (Period.compare - (Period.add (Period.day 2) (Period.hour 12)) +test (Period.compare + (Period.add (Period.day 2) (Period.hour 12)) (Period.hour 60) = 0) "Period.compare =";; -test - (add (make 1 2 3 4 5 6) (Period.make 9 8 7 6 5 4) = make 10 10 10 10 10 10) +test + (add (make 1 2 3 4 5 6) (Period.make 9 8 7 6 5 4) = make 10 10 10 10 10 10) "add 1-2-3-4-5-6 9-8-7-6-5-4";; -test +test (add (make 3 1 1 0 0 0) (Period.make 0 0 0 (-25) 0 (-1)) = make 2 12 30 22 59 59) "add 3-1-1-0-0-0 0-0-0-(-25)-0-(-1)";; -test - (equal (rem (make 9 8 7 6 5 4) (Period.make 1 2 3 4 5 6)) +test + (equal (rem (make 9 8 7 6 5 4) (Period.make 1 2 3 4 5 6)) (make 8 6 4 1 59 58)) "rem 9-8-7-6-5-4 1-2-3-4-5-6";; -test (sub (make 0 0 7 6 5 4) (make 0 0 3 54 5 6) = Period.make 0 0 1 23 59 58) +test (Period.equal + (sub (make 0 0 7 6 5 4) (make 0 0 3 54 5 6)) + (Period.make 0 0 1 23 59 58)) "sub 0-0-7-6-5-4 0-0-3-54-5-6";; -test (Period.equal - (Period.opp (Period.make 0 0 2 3 0 0)) +test (Date.Period.ymd + (Period.to_date + (precise_sub (make 2010 10 5 0 0 0) (make 2010 6 2 0 0 0))) + = (0, 4, 3)) +"precise_sub 2010-10-5 2010-6-2";; +test (Date.Period.ymd + (Period.to_date + (precise_sub (make 2010 10 5 0 2 3) (make 2010 6 5 0 0 0))) = + (0, 4, 0)) +"precise_sub 2010-10-5 2010-6-2";; +test (Date.Period.ymd + (Period.to_date + (precise_sub (make 2010 10 5 0 32 12) (make 2010 6 6 0 31 3))) + = (0, 3, 29)) +"precise_sub 2010-10-5 2010-6-6";; +test (Date.Period.ymd + (Period.to_date + (precise_sub (make 2010 10 5 1 3 3) (make 2010 6 4 0 23 3))) = + (0, 4, 1)) +"precise_sub 2010-10-5 2010-6-4";; +test (Date.Period.ymd + (Period.to_date + (precise_sub (make 2010 1 1 0 0 0) (make 2000 1 1 0 0 0))) + = (10, 0, 0)) +"precise_sub 2010-1-1 2000-1-1";; + +test (Period.equal + (Period.opp (Period.make 0 0 2 3 0 0)) (Period.make 0 0 (-2) (-3) 0 0)) "period opp";; @@ -67,18 +123,18 @@ test (not (is_julian (make 1583 1 1 0 0 0))) "1583-1-1 not julian";; (* Time *) -test (let n = Unix.gmtime (Unix.time ()) in +test (let n = Unix.gmtime (Unix.time ()) in hour (from_unixtm n) = n.Unix.tm_hour) "from_unixtm invariant UTC";; -test (let n = Unix.time () in - hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) +test (let n = Unix.time () in + hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) "from_unixfloat invariant UTC";; Time_Zone.change (Time_Zone.UTC_Plus 10);; -test (let n = Unix.gmtime (Unix.time ()) in +test (let n = Unix.gmtime (Unix.time ()) in hour (from_unixtm n) = n.Unix.tm_hour) "from_unixtm invariant +10";; -test (let n = Unix.time () in - hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) +test (let n = Unix.time () in + hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) "from_unixfloat invariant +10";; test (equal (add (make 0 0 0 10 0 0) (Period.hour 30)) (make 0 0 1 16 0 0)) @@ -87,10 +143,10 @@ test (equal (next (make 1999 12 31 23 59 59) `Second) (make 2000 1 1 0 0 0)) "next 1999-31-12-23-59-59 `Second";; let n = now ();; test (equal (prev (next n `Minute) `Minute) n) "prev next = id";; -test (equal - (convert - (make 0 0 0 23 0 0) - (Time_Zone.UTC_Plus 2) +test (equal + (convert + (make 0 0 0 23 0 0) + (Time_Zone.UTC_Plus 2) (Time_Zone.UTC_Plus 4)) (make 0 0 1 1 0 0)) "convert";; test (hour (make 0 0 0 20 0 0) = 20) "hour";; @@ -105,26 +161,30 @@ test (not (is_am (make 0 0 0 34 0 0))) "not (is_pm 34 0 0)";; Time_Zone.change Time_Zone.UTC;; -test (let n = Unix.gmtime (Unix.time ()) in +test (let n = Unix.gmtime (Unix.time ()) in hour (from_unixtm n) = n.Unix.tm_hour) "from_unixtm invariant UTC2";; test (let n = Unix.time () in - hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) + hour (from_unixfloat n) = (Unix.gmtime n).Unix.tm_hour) "from_unixfloat invariant UTC2";; test (to_unixfloat (make 1970 1 1 0 0 0) = 0.) "to_unixfloat 1 Jan 1970";; test (from_unixfloat 0. = make 1970 1 1 0 0 0) "from_unixfloat 1 Jan 1970";; test (Utils.Float.equal (to_unixfloat (make 2004 11 13 19 17 9)) 1100373429.) "to_unixfloat";; -test (equal (from_unixfloat 1100373429.) (make 2004 11 13 19 17 9)) +test (equal (from_unixfloat 1100373429.) (make 2004 11 13 19 17 9)) "from_unixfloat";; -test (from_unixtm (to_unixtm (make 2003 7 16 23 22 21)) = - make 2003 7 16 23 22 21) +test (from_unixtm (to_unixtm (make 2003 7 16 23 22 21)) = + make 2003 7 16 23 22 21) "from_unixtm to_unixtm = id";; -test (Period.to_time (Period.second 30) = Time.Period.second 30) +test (Period.to_time (Period.second 30) = Time.Period.second 30) "Period.to_time second";; -test (Period.to_time (Period.day 6) = Time.Period.second 518400) +test (Period.to_time (Period.day 6) = Time.Period.second 518400) "Period.to_time day";; +test (Period.safe_to_time (Period.second 30) = Time.Period.second 30) + "Period.safe_to_time second";; +test (Period.safe_to_time (Period.day 6) = Time.Period.second 518400) + "Period.safe_to_time day";; test_exn (lazy (Period.to_time (Period.year 1))) "Period.to_time year";; test (Period.ymds (Period.make 1 2 3 1 2 3) = (1, 2, 3, 3723)) "Period.ymds";; test diff --git a/tests/test_date.ml b/tests/test_date.ml index 6036528..86155ae 100644 --- a/tests/test_date.ml +++ b/tests/test_date.ml @@ -1,4 +1,24 @@ -(*i $Id: test_date.ml,v 1.22 2009/02/23 10:33:17 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) Printf.printf "Tests of Date:\n";; @@ -26,6 +46,16 @@ test (rem (make 2007 2 30) (Period.month 40) = make 2003 11 2) "2008-2-30 - 40 mois";; let d2 = make (-3000) 1 1;; test (rem d (sub d d2) = d2) "rem x (sub x y) = y";; +test (Period.ymd (precise_sub (make 2010 10 5) (make 2010 6 2)) = (0, 4, 3)) +"precise_sub 2010-10-5 2010-6-2";; +test (Period.ymd (precise_sub (make 2010 10 5) (make 2010 6 5)) = (0, 4, 0)) +"precise_sub 2010-10-5 2010-6-2";; +test (Period.ymd (precise_sub (make 2010 10 5) (make 2010 6 6)) = (0, 3, 29)) +"precise_sub 2010-10-5 2010-6-6";; +test (Period.ymd (precise_sub (make 2010 10 5) (make 2010 6 4)) = (0, 4, 1)) +"precise_sub 2010-10-5 2010-6-4";; +test (Period.ymd (precise_sub (make 2010 1 1) (make 2000 1 1)) = (10, 0, 0)) +"precise_sub 2010-1-1 2000-1-1";; test (from_jd 0 = make (-4712) 1 1) "from_jd 0 = 4713 BC-1-1";; test (to_jd (from_jd 12345) = 12345) "to_jd (from_jd x) = x";; test (from_mjd 0 = make 1858 11 17) "from_mjd 0 = 1858-11-17";; @@ -60,21 +90,33 @@ test (weeks_in_year 2000 = 52) "weeks_in_year 2000";; test (weeks_in_year 2020 = 53) "weeks_in_year 2020";; test (weeks_in_year 1991 = 52) "weeks_in_year 1991";; test (weeks_in_year 1999 = 52) "weeks_in_year 1999";; +test (days_in_month (make 2000 2 18) = 29) "days_in_month 2000-2-18";; +test (days_in_month (make_year_month 2000 2) = 29) "days_in_month 2000-2";; +(* untypable: *) +(* test (days_in_month ((make_year 2000 :> [ `Year | `Month ] Date.date)) = 29) "days_in_month 2000-2";; *) +test (days_in_year 1900 = 365) "days_in_year 1900";; test (century 2000 = 20) "century 2000";; test (century 2001 = 21) "century 2001";; test (millenium 2000 = 2) "millenium 2000";; test (millenium 2001 = 3) "millenium 2001";; +test (year (make_year_month 2000 3) = 2000) "year 2000-3";; +test (year (make_year 2000) = 2000) "year 2000";; +test (month (make 2000 4 23) = Apr) "year 2000-4-23";; +test (month (make_year_month 2000 3) = Mar) "year 2000-3";; +(* untypable: *) +(*test (month (make_year 2000) = Mar) "year 2000";;*) test (easter 2003 = make 2003 4 20) "Paques 2003";; test (Period.nb_days (Period.make 0 0 6) = 6) "Period.nb_days ok";; +test (Period.safe_nb_days (Period.week 3) = 21) "Period.safe_nb_days ok";; test_exn (lazy (Period.nb_days (Period.make 1 0 0))) "Period.nb_days ko";; -test (week_first_last 21 2004 = (make 2004 5 17, make 2004 5 23)) +test (week_first_last 21 2004 = (make 2004 5 17, make 2004 5 23)) "week_beggining_end";; test (Period.ymd (Period.make 1 2 3) = (1, 2, 3)) "Period.ymd";; -test (nth_weekday_of_month 2004 Oct Thu 4 = make 2004 10 28) +test (nth_weekday_of_month 2004 Oct Thu 4 = make 2004 10 28) "nth_weekday_of_month";; -test (nth_weekday_of_month 2006 Mar Fri 3 = make 2006 3 17) +test (nth_weekday_of_month 2006 Mar Fri 3 = make 2006 3 17) "nth_weekday_of_month";; -test (equal (from_day_of_year 2008 39) (make 2008 2 8)) +test (equal (from_day_of_year 2008 39) (make 2008 2 8)) "from_day_of_year";; test (is_valid_date 2008 2 8) "is_valid_date";; test (not (is_valid_date 2008 2 30)) "not is_valid_date";; @@ -85,21 +127,21 @@ test (to_unixfloat (make 1970 1 1) = 0.) "to_unixfloat 1 Jan 1970";; test (from_unixfloat 0. = make 1970 1 1) "from_unixfloat 0.";; test (to_unixfloat (make 2004 11 13) = 1100304000.) "to_unixfloat";; test (from_unixfloat 1100304000. = make 2004 11 13) "from_unixfloat";; -test (from_unixtm (to_unixtm (make 2003 7 16)) = make 2003 7 16) +test (from_unixtm (to_unixtm (make 2003 7 16)) = make 2003 7 16) "from_unixtm to_unixtm = id";; Time_Zone.change (Time_Zone.UTC_Plus (-1));; test (from_unixfloat 0. = make 1969 12 31) "from_unixfloat 0. (dec-)";; -test (from_unixtm { Unix.tm_sec = 0; tm_min = 0; tm_hour = 0; tm_mday = 1; - tm_mon = 0; tm_year = 70; tm_wday = 4; tm_yday = 0; - tm_isdst = false } = make 1969 12 31) +test (from_unixtm { Unix.tm_sec = 0; tm_min = 0; tm_hour = 0; tm_mday = 1; + tm_mon = 0; tm_year = 70; tm_wday = 4; tm_yday = 0; + tm_isdst = false } = make 1969 12 31) "from_unixtm (dec-)";; Time_Zone.change (Time_Zone.UTC_Plus 1);; test (from_unixfloat 1100390390. = make 2004 11 14) "from_unixfloat (dec+)";; -test (from_unixtm { Unix.tm_sec = 0; tm_min = 0; tm_hour = 0; tm_mday = 14; +test (from_unixtm { Unix.tm_sec = 0; tm_min = 0; tm_hour = 0; tm_mday = 14; tm_mon = 10; tm_year = 104; tm_wday = 0; tm_yday = 318; - tm_isdst = false } = make 2004 11 14) + tm_isdst = false } = make 2004 11 14) "from_unixtm (dec+)";; -test (from_unixtm (to_unixtm (make 2003 7 16)) = make 2003 7 16) +test (from_unixtm (to_unixtm (make 2003 7 16)) = make 2003 7 16) "from_unixtm to_unixtm = id";; (* to_business *) diff --git a/tests/test_fcalendar.ml b/tests/test_fcalendar.ml index 4394c16..6171028 100644 --- a/tests/test_fcalendar.ml +++ b/tests/test_fcalendar.ml @@ -1,4 +1,26 @@ -(*i $Id: test_fcalendar.ml,v 1.3 2008/02/08 10:36:14 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_fcalendar.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Fcalendar:\n";; @@ -141,6 +163,10 @@ test (Period.to_time (Period.second 30.12) = Time.Period.second 30.12) "Period.to_time second";; test (Period.to_time (Period.day 6) = Time.Period.second 518400.) "Period.to_time day";; +test (Period.safe_to_time (Period.second 30.12) = Time.Period.second 30.12) + "Period.safe_to_time second";; +test (Period.safe_to_time (Period.day 6) = Time.Period.second 518400.) + "Period.safe_to_time day";; test_exn (lazy (Period.to_time (Period.year 1))) "Period.to_time year";; test (Period.ymds (Period.make 1 2 3 1 2 3.1) = (1, 2, 3, 3723.1)) "Period.ymds";; diff --git a/tests/test_fpcalendar.ml b/tests/test_fpcalendar.ml index 03b591a..b364c48 100644 --- a/tests/test_fpcalendar.ml +++ b/tests/test_fpcalendar.ml @@ -1,4 +1,26 @@ -(*i $Id: test_fpcalendar.ml,v 1.2 2008/02/08 10:36:14 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_fpcalendar.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of FPcalendar:\n";; @@ -131,10 +153,10 @@ test (equal (make 2003 7 16 23 22 21.)) "from_unixtm to_unixtm = id";; -test (Period.to_time (Period.second 30.12) = Time.Period.second 30.12) - "Period.to_time second";; -test (Period.to_time (Period.day 6) = Time.Period.second 518400.) - "Period.to_time day";; +test (Period.safe_to_time (Period.second 30.12) = Time.Period.second 30.12) + "Period.safe_to_time second";; +test (Period.safe_to_time (Period.day 6) = Time.Period.second 518400.) + "Period.safe_to_time day";; test_exn (lazy (Period.to_time (Period.year 1))) "Period.to_time year";; test (Period.ymds (Period.make 1 2 3 1 2 3.1) = (1, 2, 3, 3723.1)) "Period.ymds";; diff --git a/tests/test_ftime.ml b/tests/test_ftime.ml index 70d3a33..59b3cd6 100644 --- a/tests/test_ftime.ml +++ b/tests/test_ftime.ml @@ -1,4 +1,26 @@ -(*i $Id: test_ftime.ml,v 1.3 2008/12/05 14:01:46 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_ftime.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Ftime:\n";; diff --git a/tests/test_pcalendar.ml b/tests/test_pcalendar.ml index 5836d3a..5482c3f 100644 --- a/tests/test_pcalendar.ml +++ b/tests/test_pcalendar.ml @@ -1,4 +1,26 @@ -(*i $Id: test_pcalendar.ml,v 1.2 2008/02/08 10:36:14 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_pcalendar.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Precise Calendar:\n";; @@ -125,8 +147,12 @@ test (from_unixtm (to_unixtm (make 2003 7 16 23 22 21)) = test (Period.to_time (Period.second 30) = Time.Period.second 30) "Period.to_time second";; +test (Period.safe_to_time (Period.second 30) = Time.Period.second 30) + "Period.safe_to_time second";; test (Period.to_time (Period.day 6) = Time.Period.second 518400) "Period.to_time day";; +test (Period.safe_to_time (Period.day 6) = Time.Period.second 518400) + "Period.safe_to_time day";; test_exn (lazy (Period.to_time (Period.year 1))) "Period.to_time year";; test (Period.ymds (Period.make 1 2 3 1 2 3) = (1, 2, 3, 3723)) "Period.ymds";; test diff --git a/tests/test_printer.ml b/tests/test_printer.ml index 9c14756..90e39b4 100644 --- a/tests/test_printer.ml +++ b/tests/test_printer.ml @@ -1,4 +1,26 @@ -(*i $Id: test_printer.ml,v 1.12 2009/01/26 09:00:58 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_printer.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Printer:\n";; diff --git a/tests/test_time.ml b/tests/test_time.ml index 3ef22a8..04259ee 100644 --- a/tests/test_time.ml +++ b/tests/test_time.ml @@ -1,4 +1,26 @@ -(*i $Id: test_time.ml,v 1.11 2008/12/05 14:01:46 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_time.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Time:\n";; diff --git a/tests/test_timezone.ml b/tests/test_timezone.ml index c24f860..475d1f5 100644 --- a/tests/test_timezone.ml +++ b/tests/test_timezone.ml @@ -1,4 +1,26 @@ -(*i $Id: test_timezone.ml,v 1.8 2008/02/08 10:36:14 signoles Exp $ i*) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(*i $Id: test_timezone.ml 231 2010-07-05 07:54:31Z signoles $ i*) Printf.printf "Tests of Time_Zone:\n";; diff --git a/utils/example.ml b/utils/example.ml index 66405a6..1541260 100644 --- a/utils/example.ml +++ b/utils/example.ml @@ -1,4 +1,26 @@ -(* $Id: example.ml,v 1.2 2008/02/01 15:51:05 signoles Exp $ *) +(**************************************************************************) +(* *) +(* This file is part of Calendar. *) +(* *) +(* Copyright (C) 2003-2010 Julien Signoles *) +(* *) +(* you can redistribute it and/or modify it under the terms of the GNU *) +(* Lesser General Public License version 2.1 as published by the *) +(* Free Software Foundation, with a special linking exception (usual *) +(* for Objective Caml libraries). *) +(* *) +(* It is distributed in the hope that it will be useful, *) +(* but WITHOUT ANY WARRANTY; without even the implied warranty of *) +(* MERCHANTABILITY or FITNESS FOR A PARTICULAR *) +(* *) +(* See the GNU Lesser General Public Licence version 2.1 for more *) +(* details (enclosed in the file LGPL). *) +(* *) +(* The special linking exception is detailled in the enclosed file *) +(* LICENSE. *) +(**************************************************************************) + +(* $Id: example.ml 231 2010-07-05 07:54:31Z signoles $ *) (** Add a tag @example *) class example = object (self) |