Update some references to the old stdlib site

Author: bbatsov

content/bigarray.md

@@ -4,7 +4,7 @@ tags: [learning]
 
 # Bigarray
 
-[Bigarray](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Bigarray.html)
+[Bigarray](https://v2.ocaml.org/api/Bigarray.html)
 serves as a way to bypass some of the limitations with OCaml's built-in array data structures.
 
 For example:

content/command_line.md

@@ -5,8 +5,8 @@ tags: [ecosystem]
 
 # Command Line Arguments
 
-* The standard library contains the 
-[Arg](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Arg.html) module,
+* The standard library contains the
+[Arg](https://v2.ocaml.org/api/Arg.html) module,
 which has a simple syntax for defining command line arguments.
 However, it uses mutable state for arguments,
 and doesn't have a built-in way to handle things such as sub-arguments,

content/data_struct.md

@@ -9,7 +9,7 @@ tags: [ecosystem]
 A major part of a standard library's role is providing basic
 data structures and algorithms.
 All the [standard libraries](standard_libraries.md) provide these:
-* The [standard library](https://caml.inria.fr/pub/docs/manual-ocaml/libref/) contains basic data structures:
+* The [standard library](https://v2.ocaml.org/api/) contains basic data structures:
   List, Array, Immutable Map, Hashtable, Mutable Queue, Mutable Stack.
 * [Base](https://github.com/janestreet/base) contains many additional data structures.
 * [Containers](https://github.com/c-cube/ocaml-containers) is a data structure-oriented extension of the standard library.

content/ecosystem.md

@@ -154,13 +154,13 @@ For testing frameworks in OCaml, see [Testing](testing.md)
 
 ## Time and Date
 * For short-term timing requirements,
-[Sys.time](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Sys.html) can do the job.
+[Sys.time](https://v2.ocaml.org/api/Sys.html) can do the job.
 * [mtime](https://github.com/dbuenzli/mtime): wall-clock monotonic time,
 and the best choice for longer-running timing requirements.
 * [ptime](http://erratique.ch/software/ptime): POSIX time.
-* [ISO8601](https://github.com/sagotch/ISO8601.ml/) 
-* [calendar](http://calendar.forge.ocamlcore.org/) 
-* [odate](https://github.com/hhugo/odate) 
+* [ISO8601](https://github.com/sagotch/ISO8601.ml/)
+* [calendar](http://calendar.forge.ocamlcore.org/)
+* [odate](https://github.com/hhugo/odate)
 * [Timedesc](https://github.com/daypack-dev/timere): date time handling.
 * [Timere](https://github.com/daypack-dev/timere): date time reasoning.
 * [Timere-parse](https://github.com/daypack-dev/timere): natural language parsing of date, time and duration.
@@ -174,6 +174,3 @@ For GUIs and TUIs (Terminal User Interfaces), see [User Interface](ui.md)
 ## Web and Networking
 For libraries related to web development and networking,
 see [Web and Networking](web_networking.md)
-
-
-

content/faq.md

@@ -19,7 +19,7 @@ tags: [learning]
   then Prints the result.)  Many people who use an OCaml toplevel use the
   `utop` toplevel.  It's more full-featured than the `ocaml` toplevel that
   comes with an OCaml compiler. You can also evaluate OCaml expressions in an
-  editor or IDE, for example.  See the 
+  editor or IDE, for example.  See the
   [Code tools](code_tools.md)
   page.
 
@@ -29,7 +29,7 @@ tags: [learning]
   It might be a bad idea to change the syntax of types in a language that puts so much emphasis on
   types.  (Standard ML uses the same convention.  Since it and OCaml both developed from an earlier
   ML, it's likely that the convention predates OCaml.)
-  
+
   However, the type syntax kind of makes sense if you think about English syntax:  A "passenger
   ship" is a ship that carries passengers.  An `int list` is a list that contains `int`s.
   (You could also write "list of integers" in English, but then you need to add the "of".)
@@ -80,11 +80,11 @@ It's good to know what the 'gotchas' are before you head in, so you can look out
     Even if you know what you're doing with your code today, someone will come and modify
     it someday and use your polymorphic comparison on a data structure that doesn't support it.
 
-* **Semicolons and `if` statements with `let`**: 
+* **Semicolons and `if` statements with `let`**:
 When a `let` expression begins in the final branch of an `if` expression,
-a semicolon will not terminate the `let`; instead the `let` expression will include 
+a semicolon will not terminate the `let`; instead the `let` expression will include
 the code that comes after the semicolon.  One might expect that the semicolon ends the
-`if` expression, and that the code following it will execute *after* the entire `if` 
+`if` expression, and that the code following it will execute *after* the entire `if`
 expression, but instead that code is part of the  `if` expression.  This can introduce
 subtle bugs, although it is a consequence of the normal (and useful) scoping rule
 for `let`.  To make the semicolon follow the entire `if` with the embedded `let`, wrap
@@ -102,63 +102,63 @@ the `let` expression in parentheses or `begin`/`end`.  For more, see
   is not included in
     val foo : 'a -> 'a
   ```
-  This means that your function (or any other value that gets this type) is not really polymorphic, 
+  This means that your function (or any other value that gets this type) is not really polymorphic,
 and the compiler doesn't have enough information to infer its concrete type, thus it represents the unknown
 parts of the type with so called "weak type variables", the placeholders the need to be filled in by you.
-(The compiler will do it itself, if possible, but when you see the weak type in the error produced by 
-the compiler, it means that it wasn't possible, and your help is needed). 
+(The compiler will do it itself, if possible, but when you see the weak type in the error produced by
+the compiler, it means that it wasn't possible, and your help is needed).
 
   The [Weak Type Variables](weak_type_variables.md) article describes in detail why they exist in OCaml and
-how to cope with them.   
+how to cope with them.
 
 ## Syntax
 
 * **Printf directives**: Where can I find a list of `printf`, `sprintf`,
-  etc. directives such as `%s`, `%b`, `%d`, `%f`, etc.?  
-  
+  etc. directives such as `%s`, `%b`, `%d`, `%f`, etc.?
+
   See the [Printf
-  module documentation](http://caml.inria.fr/pub/docs/manual-ocaml/libref/Printf.html)
+  module documentation](http://v2.ocaml.org/api/Printf.html)
   in the OCaml Manual.
 
 * **Infix operators**: Where can I find documentation on standard infix
   operators such as `@@`?
-  
+
   For general documentation on operators, see the OCaml manual: [Operators](https://caml.inria.fr/pub/docs/manual-ocaml/expr.html#sec151)
-  in the Expressions section, [Index of values](http://caml.inria.fr/pub/docs/manual-ocaml/libref/index_values.html), or the 
-  [Stdlib module documentation](http://caml.inria.fr/pub/docs/manual-ocaml/libref/Stdlib.html). For the Stdlib document,
+  in the Expressions section, [Index of values](http://v2.ocaml.org/api/index_values.html), or the
+  [Stdlib module documentation](http://v2.ocaml.org/api/Stdlib.html). For the Stdlib document,
   you'll want to search the page for "operator" or for the specific operator you're interested in.
-  
+
   For operator precedence and associativity, see the [Expressions](https://caml.inria.fr/pub/docs/manual-ocaml/expr.html)
-  section of the manual, and scroll down past the BNF syntax specification or search for "Construction or operator".  The 
+  section of the manual, and scroll down past the BNF syntax specification or search for "Construction or operator".  The
   Stdlib module also specifies precedence and associativity in the documentation for each operator.
-  
+
   (Also possibly useful: [Built-in operators and functions](https://www2.lib.uchicago.edu/keith/ocaml-class/operators.html)
   at *OCaml for the Skeptical*.)
 
 * **ppx**: What are these `[%% ...]`, `[@@ ...]` expressions that I
-  see in people's code?  What does it mean when there's a percent sign in the 
+  see in people's code?  What does it mean when there's a percent sign in the
   middle of a name, as in `let%lwt`? What are extension points?
-  
+
   See [A Guide to PreProcessor eXtensions](ppx.md) or [A Tutorial to OCaml -ppx Language Extensions](https://www.victor.darvariu.me/jekyll/update/2018/06/19/ppx-tutorial.html).
 
 * **+'a, -'a**: Why are some type variables prefaced by "+" or "-",
   as in `type +'a t`?
-  
+
   These are called "variance annotations".  They're used to constrain
   subtyping relations.  See [+'a and
   -'a](https://blog.janestreet.com/a-and-a) at the Jane Street Tech
   Blog.
 
 * **open!**: What's the difference between `open My_module` and
   `open! My_module`?
-  
+
   Both make the values and types in `My_module` available without having
   to write "My_module." in front of them.  `open My_module` will trigger
   a warning if `My_module` overrides existing definitions.  `open!` suppresses
   this warning.  See [Overriding in open statements](http://caml.inria.fr/pub/docs/manual-ocaml/extn.html#sec250)
   from [Chapter 8 Language extensions](http://caml.inria.fr/pub/docs/manual-ocaml/extn.html) in
-  the OCaml manual.  
-  
+  the OCaml manual.
+
   At present `open!` also suppresses another warning as well.  This is a warning
   that no definition in the opened module is in fact used within
   `open!`'s scope.  There is some disagreement about whether this behavior
@@ -167,4 +167,3 @@ how to cope with them.
   a module as a way of providing an alternative standard programming environment.
   See the discussion at this OCaml PR: [Fix PR6638: "unused open" warning was incorrectly suppressed
   by "open!"](https://github.com/ocaml/ocaml/pull/1110).
-

content/iterators.md

@@ -3,7 +3,7 @@
 ## Available Options
 
 * As of 4.07, OCaml has a built-in
-[Seq](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html)
+[Seq](https://v2.ocaml.org/api/Seq.html)
 type, which every Stdlib data structure can convert to and from.
 Technically, this is a generator.
 Making use of this type will increase performance when running
@@ -90,7 +90,7 @@ to actually import the `Iter` library for a data structure to use it.
 `Streaming.Stream` avoids inner mutable types, but they're essentially hidden from the user at the `Iter` level.
 `Streaming.Stream` also has resource cleanup as part of its design,
 for example when streaming from a file or socket.
-For `Iter`, resource cleanup is not built in, and 
+For `Iter`, resource cleanup is not built in, and
 usage of a `with_resource` function is required for resource cleanup.
 
 ## Recommendations

content/learning.md

@@ -115,7 +115,7 @@ How to program OCaml in the new multicore-OCaml runtime.
 
 ### The Format Module
 
-The Stdlib has the [Format](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Format.html)
+The Stdlib has the [Format](https://v2.ocaml.org/api/Format.html)
 module for pretty printing.
 It's a little tricky to get a hang of.
 * [Tutorial](https://ocaml.org/learn/tutorials/format.html)

content/pretty_printing.md

@@ -5,7 +5,7 @@ tags: [ecosystem]
 
 # Pretty Printing
 
-* [Format](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Format.html):
+* [Format](https://v2.ocaml.org/api/Format.html):
 stdlib module using the notion of boxes to lay out pretty-printing commands.
 It's recommended to use one of the abstractions below instead.
 * [CCFormat](https://github.com/c-cube/ocaml-containers/blob/master/src/core/CCFormat.mli):

content/process_management.md

@@ -1,6 +1,6 @@
 # Process Management and Shell Scripting
 
-* The standard library contains the [Unix](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html) module,
+* The standard library contains the [Unix](https://v2.ocaml.org/api/Unix.html) module,
 which allows for low-level process management.
 This is fairly brittle due to the fact that it's mostly (but not entirely) tailored towards Unix.
 * [shexp](https://github.com/janestreet/shexp):
@@ -10,6 +10,6 @@ In fact, this is one of the few libraries that supports piping properly.
 * [feather](https://github.com/charlesetc/feather):
 Lightweight shell scripting and process management.
 [docs](https://github.com/charlesetc/feather/blob/master/README.md).
-* [lwt](https://github.com/ocsigen/lwt) has the 
+* [lwt](https://github.com/ocsigen/lwt) has the
 [lwt_process](https://ocsigen.org/lwt/3.2.1/api/Lwt_process) module,
 which has cross-platform process manipulation functions.

content/regular_expressions.md

@@ -14,7 +14,7 @@ matched groups.
 interface for 90% of your regex needs.
 This is a binding on top of Re.
 * OCaml comes with the
-[Str](https://caml.inria.fr/pub/docs/manual-ocaml/libref/Str.html) module.
+[Str](https://v2.ocaml.org/api/Str.html) module.
 This module is __not__ recommended because it is not part of the standard library,
 it uses global states and is not particularly fast, but its availability makes it
 useful when you don't have access to anything better.