jvdp1
diff --git a/‎.github/workflows/CI.yml
+8-2 b/‎.github/workflows/CI.yml
+8-2
diff --git a/‎.github/workflows/ci_windows.yml
+3-1 b/‎.github/workflows/ci_windows.yml
+3-1
diff --git a/‎CMakeLists.txt
+1-5 b/‎CMakeLists.txt
+1-5
diff --git a/‎README.md
+26-7 b/‎README.md
+26-7
diff --git a/‎WORKFLOW.md
+55-3 b/‎WORKFLOW.md
+55-3
diff --git a/‎src/CMakeLists.txt
+19-1 b/‎src/CMakeLists.txt
+19-1
diff --git a/‎src/Makefile.manual
+7-1 b/‎src/Makefile.manual
+7-1
@@ -7,6 +7,7 @@ env:
   CMAKE_BUILD_PARALLEL_LEVEL: "2" # 2 cores on each GHA VM, enable parallel builds
   CTEST_OUTPUT_ON_FAILURE: "ON" # This way we don't need a flag to ctest
   CTEST_PARALLEL_LEVEL: "2"
+  CTEST_TIME_TIMEOUT: "5"  # some failures hang forever
   HOMEBREW_NO_ANALYTICS: "ON" # Make Homebrew installation a little quicker
   HOMEBREW_NO_AUTO_UPDATE: "ON"
   HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: "ON"
@@ -55,10 +56,15 @@ jobs:
       run: cmake -Wdev -DCMAKE_BUILD_TYPE=Release -S . -B build
 
     - name: Build and compile
-      run: cmake --build build || cmake --build build --verbose --parallel 1
+      run: cmake --build build
+
+    - name: catch build fail
+      run: cmake --build build --verbose --parallel 1
+      if: failure()
 
     - name: test
-      run: cmake --build build --target test
+      run: ctest --parallel --output-on-failure
+      working-directory: build
 
     - name: Test in-tree builds
       if: contains( matrix.gcc_v, '9') # Only test one compiler on each platform
 
@@ -4,6 +4,7 @@ on: [push, pull_request]
 
 env:
   CI: "ON"
+  CTEST_TIME_TIMEOUT: "5"  # some failures hang forever
 
 jobs:
   Build:
@@ -24,7 +25,8 @@ jobs:
     - name: CMake build
       run: cmake --build build --parallel
 
-    - run: cmake --build build --verbose --parallel 1
+    - name: catch build fail
+      run: cmake --build build --verbose --parallel 1
       if: failure()
 
     - name: CTest
 
@@ -2,11 +2,6 @@ cmake_minimum_required(VERSION 3.14.0)
 project(stdlib Fortran)
 enable_testing()
 
-# this avoids stdlib and projects using stdlib from having to introspect stdlib's directory structure
-# FIXME: this eventually needs to be handled more precisely, as this spills all .mod/.smod into one directory
-#  and thereby can clash if module/submodule names are the same in different parts of library
-set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR})
-
 # --- compiler options
 if(CMAKE_Fortran_COMPILER_ID STREQUAL GNU)
   add_compile_options(-fimplicit-none)
@@ -20,6 +15,7 @@ endif()
 include(CheckFortranSourceCompiles)
 include(CheckFortranSourceRuns)
 check_fortran_source_compiles("error stop i; end" f18errorstop SRC_EXT f90)
+check_fortran_source_compiles("real, allocatable :: array(:, :, :, :, :, :, :, :, :, :); end" f03rank SRC_EXT f90)
 check_fortran_source_runs("use, intrinsic :: iso_fortran_env, only : real128; real(real128) :: x; x = x+1; end" f03real128)
 
 add_subdirectory(src)
@@ -1,5 +1,24 @@
 # Fortran Standard Library
 
+[![Actions Status](https://github.com/fortran-lang/stdlib/workflows/CI/badge.svg)](https://github.com/fortran-lang/stdlib/actions)
+[![Actions Status](https://github.com/fortran-lang/stdlib/workflows/CI_windows/badge.svg)](https://github.com/fortran-lang/stdlib/actions)
+
+
+## Goals and Motivation
+
+The Fortran Standard, as published by the ISO (https://wg5-fortran.org/), does
+not have a Standard Library. The goal of this project is to provide a community
+driven and agreed upon *de facto* "standard" library for Fortran, called a
+Fortran Standard Library (`stdlib`). We have a rigorous process how `stdlib` is
+developed as documented in our [Workflow](WORKFLOW.md). `stdlib` is both a
+specification and a reference implementation. We are cooperating with the
+Fortran Standards Committee (e.g., the effort
+[started](https://github.com/j3-fortran/fortran_proposals/issues/104) at the J3
+committee repository) and the plan is to continue working with the Committee in
+the future (such as in the step 5. in the [Workflow](WORKFLOW.md) document), so
+that if the Committee wants to standardize some feature already available in `stdlib`, it would
+base it on `stdlib`'s implementation.
+
 ## Scope
 
 The goal of the Fortran Standard Library is to achieve the following general scope:
@@ -16,19 +35,19 @@ The goal of the Fortran Standard Library is to achieve the following general sco
 
 ### Get the code
 
-```
+```sh
 git clone https://github.com/fortran-lang/stdlib
 cd stdlib
 ```
 
 ### Build with CMake
 
-```
-mkdir build
-cd build
-cmake ..
-make
-ctest
+```sh
+cmake -B build
+
+cmake --build build
+
+cmake --build build --target test
 ```
 
 ### Build with make
 
@@ -1,5 +1,57 @@
 # Workflow for the Fortran stdlib contributors
 
-This document will describe the workflow we'll follow when developing the Fortran stdlib.
-It's largely to be discussed and decided.
-For now, take a look at the [issues](https://github.com/fortran-lang/stdlib).
+This document describes our current workflow.
+
+We welcome everyone and anyone to participate and propose additions to stdlib.
+It is okay if you do not have experience for specification or implementation,
+but have an idea for stdlib. If the idea is popular among the community, more
+experienced contributors will help it through all 5 steps.
+
+
+1. **Idea**: You have an idea or a proposal. Open an
+   [issue](https://github.com/fortran-lang/stdlib/issues) to discuss it. This
+   is on the level of "is there interest in having image reader/writer
+   functions in stdlib?" The goal of this step is to find out if the community
+   is interested in having this functionality as part of stdlib.
+
+2. **API**: When there seems to be significant interest in the proposal (vast
+   majority of participants think it is a good idea), move on to discuss the
+   specific API. It's OK to propose the API off the bat if you already have an
+   idea for it. This step is exploratory and its goal is to find out what the
+   API should *look* and *feel* like.
+
+3. **Specification**: Discuss the API and iterate. When there is vast majority
+   approval for the API, move on to implement it and submit a PR. Small PRs are
+   always better than large.  It is OK to implement only a few functions of a
+   new module, and continue work on the others in a later PR. All new
+   functionality goes into an "experimental" namespace
+   (`stdlib_experimental_*.f90`).  As part of the PR, when submitting a new
+   public facing API, please provide the initial draft of the specification
+   document as well as the the initial reference implementation of this
+   specification.  The specification is a document that describes the API and
+   the functionality, so that anyone can use it to create an implementation
+   from scratch without looking at `stdlib`. The `stdlib` library then provides
+   the reference implementation.
+
+4. **Implementation** in experimental: When opening a PR, request reviews from
+   one or more people that are most relevant to it. These are likely to be
+   people involved in prior steps of the workflow. Other contributors (not
+   explicitly invited) are encouraged to provide reviews and suggestions as
+   well. Iterate until all (or most) participants are on the same page.
+   We can merge when there is vast majority approval of the PR.
+
+5. **Release**: Moving from experimental to release. The experimental
+   "namespace" contains new functionality together with its specification. In
+   order to move from experimental to release, the specification document must
+   be approved by the wide community and the standards committee (informally).
+   If that happens, it has now been blessed for broad use and we can move the
+   code into the main section of `stdlib`, and the particular specification
+   document becomes part of the Fortran Standard Library.
+
+
+Note: the general term "vast majority" above means at least 80%, but ultimately
+it is left to our best judgement to ensure that the community agrees that each
+PR and proposal was approved by "vast majority".
+
+You are welcome to propose changes to this workflow by opening an
+[issue](https://github.com/fortran-lang/stdlib/issues).
@@ -2,22 +2,40 @@ set(SRC
     stdlib_experimental_ascii.f90
     stdlib_experimental_io.f90
     stdlib_experimental_error.f90
-    stdlib_experimental_optval.f90
     stdlib_experimental_kinds.f90
+    stdlib_experimental_optval.f90
+    stdlib_experimental_system.F90
 )
 
 add_library(fortran_stdlib ${SRC})
 
+set(LIB_MOD_DIR ${CMAKE_CURRENT_BINARY_DIR}/mod_files/)
+set_target_properties(fortran_stdlib PROPERTIES
+    Fortran_MODULE_DIRECTORY ${LIB_MOD_DIR})
+target_include_directories(fortran_stdlib PUBLIC
+    $<BUILD_INTERFACE:${LIB_MOD_DIR}>
+    $<INSTALL_INTERFACE:include>
+)
+
 if(f18errorstop)
   target_sources(fortran_stdlib PRIVATE f18estop.f90)
 else()
   target_sources(fortran_stdlib PRIVATE f08estop.f90)
 endif()
 
+if(f03rank)
+  target_sources(fortran_stdlib PRIVATE f03_stdlib_experimental_stats.f90)
+  target_sources(fortran_stdlib PRIVATE f03_stdlib_experimental_stats_mean.f90)
+else()
+  target_sources(fortran_stdlib PRIVATE f90_stdlib_experimental_stats.f90)
+  target_sources(fortran_stdlib PRIVATE f90_stdlib_experimental_stats_mean.f90)
+endif()
+
 add_subdirectory(tests)
 
 install(TARGETS fortran_stdlib
         RUNTIME DESTINATION bin
         ARCHIVE DESTINATION lib
         LIBRARY DESTINATION lib
     )
+install(DIRECTORY ${LIB_MOD_DIR} DESTINATION include)
@@ -3,7 +3,9 @@ SRC = stdlib_experimental_ascii.f90 \
       stdlib_experimental_io.f90 \
       stdlib_experimental_optval.f90 \
       stdlib_experimental_kinds.f90 \
-      f18estop.f90
+      f18estop.f90 \
+      f03_stdlib_experimental_stats.f90 \
+      f03_stdlib_experimental_stats_mean.f90 
 
 LIB = libstdlib.a
 
@@ -34,3 +36,7 @@ stdlib_experimental_io.o: \
 	stdlib_experimental_optval.o \
 	stdlib_experimental_kinds.o
 stdlib_experimental_optval.o: stdlib_experimental_kinds.o
+f03_stdlib_experimental_stats_mean.o: \
+	stdlib_experimental_optval.o \
+	stdlib_experimental_kinds.o \
+	f03_stdlib_experimental_stats.o